]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Minor demo tweaks
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.27
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29 /***********************************************************************
30 *
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 *
34 ************************************************************************/
35
36 /* template workaround for compilers that cannot correctly implement the C++ standard */
37 #ifndef SWIGTEMPLATEDISAMBIGUATOR
38 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 #endif
44
45 /* inline attribute */
46 #ifndef SWIGINLINE
47 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
48 # define SWIGINLINE inline
49 # else
50 # define SWIGINLINE
51 # endif
52 #endif
53
54 /* attribute recognised by some compilers to avoid 'unused' warnings */
55 #ifndef SWIGUNUSED
56 # if defined(__GNUC__) || defined(__ICC)
57 # define SWIGUNUSED __attribute__ ((unused))
58 # else
59 # define SWIGUNUSED
60 # endif
61 #endif
62
63 /* internal SWIG method */
64 #ifndef SWIGINTERN
65 # define SWIGINTERN static SWIGUNUSED
66 #endif
67
68 /* internal inline SWIG method */
69 #ifndef SWIGINTERNINLINE
70 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
71 #endif
72
73 /* exporting methods for Windows DLLs */
74 #ifndef SWIGEXPORT
75 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
76 # if defined(STATIC_LINKED)
77 # define SWIGEXPORT
78 # else
79 # define SWIGEXPORT __declspec(dllexport)
80 # endif
81 # else
82 # define SWIGEXPORT
83 # endif
84 #endif
85
86 /* calling conventions for Windows */
87 #ifndef SWIGSTDCALL
88 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
89 # define SWIGSTDCALL __stdcall
90 # else
91 # define SWIGSTDCALL
92 # endif
93 #endif
94
95
96
97 #include <Python.h>
98
99 /***********************************************************************
100 * swigrun.swg
101 *
102 * This file contains generic CAPI SWIG runtime support for pointer
103 * type checking.
104 *
105 ************************************************************************/
106
107 /* This should only be incremented when either the layout of swig_type_info changes,
108 or for whatever reason, the runtime changes incompatibly */
109 #define SWIG_RUNTIME_VERSION "2"
110
111 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
112 #ifdef SWIG_TYPE_TABLE
113 # define SWIG_QUOTE_STRING(x) #x
114 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
115 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
116 #else
117 # define SWIG_TYPE_TABLE_NAME
118 #endif
119
120 /*
121 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
122 creating a static or dynamic library from the swig runtime code.
123 In 99.9% of the cases, swig just needs to declare them as 'static'.
124
125 But only do this if is strictly necessary, ie, if you have problems
126 with your compiler or so.
127 */
128
129 #ifndef SWIGRUNTIME
130 # define SWIGRUNTIME SWIGINTERN
131 #endif
132
133 #ifndef SWIGRUNTIMEINLINE
134 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
135 #endif
136
137 #include <string.h>
138
139 #ifdef __cplusplus
140 extern "C" {
141 #endif
142
143 typedef void *(*swig_converter_func)(void *);
144 typedef struct swig_type_info *(*swig_dycast_func)(void **);
145
146 /* Structure to store inforomation on one type */
147 typedef struct swig_type_info {
148 const char *name; /* mangled name of this type */
149 const char *str; /* human readable name of this type */
150 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
151 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
152 void *clientdata; /* language specific type data */
153 } swig_type_info;
154
155 /* Structure to store a type and conversion function used for casting */
156 typedef struct swig_cast_info {
157 swig_type_info *type; /* pointer to type that is equivalent to this type */
158 swig_converter_func converter; /* function to cast the void pointers */
159 struct swig_cast_info *next; /* pointer to next cast in linked list */
160 struct swig_cast_info *prev; /* pointer to the previous cast */
161 } swig_cast_info;
162
163 /* Structure used to store module information
164 * Each module generates one structure like this, and the runtime collects
165 * all of these structures and stores them in a circularly linked list.*/
166 typedef struct swig_module_info {
167 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
168 size_t size; /* Number of types in this module */
169 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
170 swig_type_info **type_initial; /* Array of initially generated type structures */
171 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
172 void *clientdata; /* Language specific module data */
173 } swig_module_info;
174
175
176 /*
177 Compare two type names skipping the space characters, therefore
178 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
179
180 Return 0 when the two name types are equivalent, as in
181 strncmp, but skipping ' '.
182 */
183 SWIGRUNTIME int
184 SWIG_TypeNameComp(const char *f1, const char *l1,
185 const char *f2, const char *l2) {
186 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
187 while ((*f1 == ' ') && (f1 != l1)) ++f1;
188 while ((*f2 == ' ') && (f2 != l2)) ++f2;
189 if (*f1 != *f2) return (int)(*f1 - *f2);
190 }
191 return (l1 - f1) - (l2 - f2);
192 }
193
194 /*
195 Check type equivalence in a name list like <name1>|<name2>|...
196 Return 0 if not equal, 1 if equal
197 */
198 SWIGRUNTIME int
199 SWIG_TypeEquiv(const char *nb, const char *tb) {
200 int equiv = 0;
201 const char* te = tb + strlen(tb);
202 const char* ne = nb;
203 while (!equiv && *ne) {
204 for (nb = ne; *ne; ++ne) {
205 if (*ne == '|') break;
206 }
207 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
208 if (*ne) ++ne;
209 }
210 return equiv;
211 }
212
213 /*
214 Check type equivalence in a name list like <name1>|<name2>|...
215 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
216 */
217 SWIGRUNTIME int
218 SWIG_TypeCompare(const char *nb, const char *tb) {
219 int equiv = 0;
220 const char* te = tb + strlen(tb);
221 const char* ne = nb;
222 while (!equiv && *ne) {
223 for (nb = ne; *ne; ++ne) {
224 if (*ne == '|') break;
225 }
226 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
227 if (*ne) ++ne;
228 }
229 return equiv;
230 }
231
232
233 /* think of this as a c++ template<> or a scheme macro */
234 #define SWIG_TypeCheck_Template(comparison, ty) \
235 if (ty) { \
236 swig_cast_info *iter = ty->cast; \
237 while (iter) { \
238 if (comparison) { \
239 if (iter == ty->cast) return iter; \
240 /* Move iter to the top of the linked list */ \
241 iter->prev->next = iter->next; \
242 if (iter->next) \
243 iter->next->prev = iter->prev; \
244 iter->next = ty->cast; \
245 iter->prev = 0; \
246 if (ty->cast) ty->cast->prev = iter; \
247 ty->cast = iter; \
248 return iter; \
249 } \
250 iter = iter->next; \
251 } \
252 } \
253 return 0
254
255 /*
256 Check the typename
257 */
258 SWIGRUNTIME swig_cast_info *
259 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
260 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
261 }
262
263 /* Same as previous function, except strcmp is replaced with a pointer comparison */
264 SWIGRUNTIME swig_cast_info *
265 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
266 SWIG_TypeCheck_Template(iter->type == from, into);
267 }
268
269 /*
270 Cast a pointer up an inheritance hierarchy
271 */
272 SWIGRUNTIMEINLINE void *
273 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
274 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
275 }
276
277 /*
278 Dynamic pointer casting. Down an inheritance hierarchy
279 */
280 SWIGRUNTIME swig_type_info *
281 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
282 swig_type_info *lastty = ty;
283 if (!ty || !ty->dcast) return ty;
284 while (ty && (ty->dcast)) {
285 ty = (*ty->dcast)(ptr);
286 if (ty) lastty = ty;
287 }
288 return lastty;
289 }
290
291 /*
292 Return the name associated with this type
293 */
294 SWIGRUNTIMEINLINE const char *
295 SWIG_TypeName(const swig_type_info *ty) {
296 return ty->name;
297 }
298
299 /*
300 Return the pretty name associated with this type,
301 that is an unmangled type name in a form presentable to the user.
302 */
303 SWIGRUNTIME const char *
304 SWIG_TypePrettyName(const swig_type_info *type) {
305 /* The "str" field contains the equivalent pretty names of the
306 type, separated by vertical-bar characters. We choose
307 to print the last name, as it is often (?) the most
308 specific. */
309 if (type->str != NULL) {
310 const char *last_name = type->str;
311 const char *s;
312 for (s = type->str; *s; s++)
313 if (*s == '|') last_name = s+1;
314 return last_name;
315 }
316 else
317 return type->name;
318 }
319
320 /*
321 Set the clientdata field for a type
322 */
323 SWIGRUNTIME void
324 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
325 swig_cast_info *cast = ti->cast;
326 /* if (ti->clientdata == clientdata) return; */
327 ti->clientdata = clientdata;
328
329 while (cast) {
330 if (!cast->converter) {
331 swig_type_info *tc = cast->type;
332 if (!tc->clientdata) {
333 SWIG_TypeClientData(tc, clientdata);
334 }
335 }
336 cast = cast->next;
337 }
338 }
339
340 /*
341 Search for a swig_type_info structure only by mangled name
342 Search is a O(log #types)
343
344 We start searching at module start, and finish searching when start == end.
345 Note: if start == end at the beginning of the function, we go all the way around
346 the circular list.
347 */
348 SWIGRUNTIME swig_type_info *
349 SWIG_MangledTypeQueryModule(swig_module_info *start,
350 swig_module_info *end,
351 const char *name) {
352 swig_module_info *iter = start;
353 do {
354 if (iter->size) {
355 register size_t l = 0;
356 register size_t r = iter->size - 1;
357 do {
358 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
359 register size_t i = (l + r) >> 1;
360 const char *iname = iter->types[i]->name;
361 if (iname) {
362 register int compare = strcmp(name, iname);
363 if (compare == 0) {
364 return iter->types[i];
365 } else if (compare < 0) {
366 if (i) {
367 r = i - 1;
368 } else {
369 break;
370 }
371 } else if (compare > 0) {
372 l = i + 1;
373 }
374 } else {
375 break; /* should never happen */
376 }
377 } while (l <= r);
378 }
379 iter = iter->next;
380 } while (iter != end);
381 return 0;
382 }
383
384 /*
385 Search for a swig_type_info structure for either a mangled name or a human readable name.
386 It first searches the mangled names of the types, which is a O(log #types)
387 If a type is not found it then searches the human readable names, which is O(#types).
388
389 We start searching at module start, and finish searching when start == end.
390 Note: if start == end at the beginning of the function, we go all the way around
391 the circular list.
392 */
393 SWIGRUNTIME swig_type_info *
394 SWIG_TypeQueryModule(swig_module_info *start,
395 swig_module_info *end,
396 const char *name) {
397 /* STEP 1: Search the name field using binary search */
398 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
399 if (ret) {
400 return ret;
401 } else {
402 /* STEP 2: If the type hasn't been found, do a complete search
403 of the str field (the human readable name) */
404 swig_module_info *iter = start;
405 do {
406 register size_t i = 0;
407 for (; i < iter->size; ++i) {
408 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
409 return iter->types[i];
410 }
411 iter = iter->next;
412 } while (iter != end);
413 }
414
415 /* neither found a match */
416 return 0;
417 }
418
419
420 /*
421 Pack binary data into a string
422 */
423 SWIGRUNTIME char *
424 SWIG_PackData(char *c, void *ptr, size_t sz) {
425 static const char hex[17] = "0123456789abcdef";
426 register const unsigned char *u = (unsigned char *) ptr;
427 register const unsigned char *eu = u + sz;
428 for (; u != eu; ++u) {
429 register unsigned char uu = *u;
430 *(c++) = hex[(uu & 0xf0) >> 4];
431 *(c++) = hex[uu & 0xf];
432 }
433 return c;
434 }
435
436 /*
437 Unpack binary data from a string
438 */
439 SWIGRUNTIME const char *
440 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
441 register unsigned char *u = (unsigned char *) ptr;
442 register const unsigned char *eu = u + sz;
443 for (; u != eu; ++u) {
444 register char d = *(c++);
445 register unsigned char uu = 0;
446 if ((d >= '0') && (d <= '9'))
447 uu = ((d - '0') << 4);
448 else if ((d >= 'a') && (d <= 'f'))
449 uu = ((d - ('a'-10)) << 4);
450 else
451 return (char *) 0;
452 d = *(c++);
453 if ((d >= '0') && (d <= '9'))
454 uu |= (d - '0');
455 else if ((d >= 'a') && (d <= 'f'))
456 uu |= (d - ('a'-10));
457 else
458 return (char *) 0;
459 *u = uu;
460 }
461 return c;
462 }
463
464 /*
465 Pack 'void *' into a string buffer.
466 */
467 SWIGRUNTIME char *
468 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
469 char *r = buff;
470 if ((2*sizeof(void *) + 2) > bsz) return 0;
471 *(r++) = '_';
472 r = SWIG_PackData(r,&ptr,sizeof(void *));
473 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
474 strcpy(r,name);
475 return buff;
476 }
477
478 SWIGRUNTIME const char *
479 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
480 if (*c != '_') {
481 if (strcmp(c,"NULL") == 0) {
482 *ptr = (void *) 0;
483 return name;
484 } else {
485 return 0;
486 }
487 }
488 return SWIG_UnpackData(++c,ptr,sizeof(void *));
489 }
490
491 SWIGRUNTIME char *
492 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
493 char *r = buff;
494 size_t lname = (name ? strlen(name) : 0);
495 if ((2*sz + 2 + lname) > bsz) return 0;
496 *(r++) = '_';
497 r = SWIG_PackData(r,ptr,sz);
498 if (lname) {
499 strncpy(r,name,lname+1);
500 } else {
501 *r = 0;
502 }
503 return buff;
504 }
505
506 SWIGRUNTIME const char *
507 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
508 if (*c != '_') {
509 if (strcmp(c,"NULL") == 0) {
510 memset(ptr,0,sz);
511 return name;
512 } else {
513 return 0;
514 }
515 }
516 return SWIG_UnpackData(++c,ptr,sz);
517 }
518
519 #ifdef __cplusplus
520 }
521 #endif
522
523 /* -----------------------------------------------------------------------------
524 * SWIG API. Portion that goes into the runtime
525 * ----------------------------------------------------------------------------- */
526
527 #ifdef __cplusplus
528 extern "C" {
529 #endif
530
531 /* -----------------------------------------------------------------------------
532 * for internal method declarations
533 * ----------------------------------------------------------------------------- */
534
535 #ifndef SWIGINTERN
536 # define SWIGINTERN static SWIGUNUSED
537 #endif
538
539 #ifndef SWIGINTERNINLINE
540 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
541 #endif
542
543 /*
544 Exception handling in wrappers
545 */
546 #define SWIG_fail goto fail
547 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
548 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
549 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
550 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
551 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
552
553 /*
554 Contract support
555 */
556 #define SWIG_contract_assert(expr, msg) \
557 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
558
559 /* -----------------------------------------------------------------------------
560 * Constant declarations
561 * ----------------------------------------------------------------------------- */
562
563 /* Constant Types */
564 #define SWIG_PY_INT 1
565 #define SWIG_PY_FLOAT 2
566 #define SWIG_PY_STRING 3
567 #define SWIG_PY_POINTER 4
568 #define SWIG_PY_BINARY 5
569
570 /* Constant information structure */
571 typedef struct swig_const_info {
572 int type;
573 char *name;
574 long lvalue;
575 double dvalue;
576 void *pvalue;
577 swig_type_info **ptype;
578 } swig_const_info;
579
580
581 /* -----------------------------------------------------------------------------
582 * Alloc. memory flags
583 * ----------------------------------------------------------------------------- */
584 #define SWIG_OLDOBJ 1
585 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
586 #define SWIG_PYSTR SWIG_NEWOBJ + 1
587
588 #ifdef __cplusplus
589 }
590 #endif
591
592
593 /***********************************************************************
594 * pyrun.swg
595 *
596 * This file contains the runtime support for Python modules
597 * and includes code for managing global variables and pointer
598 * type checking.
599 *
600 * Author : David Beazley (beazley@cs.uchicago.edu)
601 ************************************************************************/
602
603 /* Common SWIG API */
604 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
605 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
606 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
607
608
609 /* Python-specific SWIG API */
610 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
611 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
612
613 /* Runtime API */
614 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
615 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
616
617 /* -----------------------------------------------------------------------------
618 * Pointer declarations
619 * ----------------------------------------------------------------------------- */
620 /*
621 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
622 C/C++ pointers in the python side. Very useful for debugging, but
623 not always safe.
624 */
625 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
626 # define SWIG_COBJECT_TYPES
627 #endif
628
629 /* Flags for pointer conversion */
630 #define SWIG_POINTER_EXCEPTION 0x1
631 #define SWIG_POINTER_DISOWN 0x2
632
633
634 /* Add PyOS_snprintf for old Pythons */
635 #if PY_VERSION_HEX < 0x02020000
636 #define PyOS_snprintf snprintf
637 #endif
638
639 #ifdef __cplusplus
640 extern "C" {
641 #endif
642
643 /* -----------------------------------------------------------------------------
644 * Create a new pointer string
645 * ----------------------------------------------------------------------------- */
646 #ifndef SWIG_BUFFER_SIZE
647 #define SWIG_BUFFER_SIZE 1024
648 #endif
649
650 /* A crude PyString_FromFormat implementation for old Pythons */
651 #if PY_VERSION_HEX < 0x02020000
652 static PyObject *
653 PyString_FromFormat(const char *fmt, ...) {
654 va_list ap;
655 char buf[SWIG_BUFFER_SIZE * 2];
656 int res;
657 va_start(ap, fmt);
658 res = vsnprintf(buf, sizeof(buf), fmt, ap);
659 va_end(ap);
660 return (res < 0 || res >= sizeof(buf)) ? 0 : PyString_FromString(buf);
661 }
662 #endif
663
664 #if PY_VERSION_HEX < 0x01060000
665 #define PyObject_Del(op) PyMem_DEL((op))
666 #endif
667
668 #if defined(SWIG_COBJECT_TYPES)
669 #if !defined(SWIG_COBJECT_PYTHON)
670 /* -----------------------------------------------------------------------------
671 * Implements a simple Swig Object type, and use it instead of PyCObject
672 * ----------------------------------------------------------------------------- */
673
674 typedef struct {
675 PyObject_HEAD
676 void *ptr;
677 const char *desc;
678 } PySwigObject;
679
680 /* Declarations for objects of type PySwigObject */
681
682 SWIGRUNTIME int
683 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
684 {
685 char result[SWIG_BUFFER_SIZE];
686 flags = flags;
687 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
688 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
689 return 0;
690 } else {
691 return 1;
692 }
693 }
694
695 SWIGRUNTIME PyObject *
696 PySwigObject_repr(PySwigObject *v)
697 {
698 char result[SWIG_BUFFER_SIZE];
699 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
700 PyString_FromFormat("<Swig Object at %s>", result) : 0;
701 }
702
703 SWIGRUNTIME PyObject *
704 PySwigObject_str(PySwigObject *v)
705 {
706 char result[SWIG_BUFFER_SIZE];
707 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
708 PyString_FromString(result) : 0;
709 }
710
711 SWIGRUNTIME PyObject *
712 PySwigObject_long(PySwigObject *v)
713 {
714 return PyLong_FromVoidPtr(v->ptr);
715 }
716
717 SWIGRUNTIME PyObject *
718 PySwigObject_format(const char* fmt, PySwigObject *v)
719 {
720 PyObject *res = NULL;
721 PyObject *args = PyTuple_New(1);
722 if (args && (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0)) {
723 PyObject *ofmt = PyString_FromString(fmt);
724 if (ofmt) {
725 res = PyString_Format(ofmt,args);
726 Py_DECREF(ofmt);
727 }
728 Py_DECREF(args);
729 }
730 return res;
731 }
732
733 SWIGRUNTIME PyObject *
734 PySwigObject_oct(PySwigObject *v)
735 {
736 return PySwigObject_format("%o",v);
737 }
738
739 SWIGRUNTIME PyObject *
740 PySwigObject_hex(PySwigObject *v)
741 {
742 return PySwigObject_format("%x",v);
743 }
744
745 SWIGRUNTIME int
746 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
747 {
748 int c = strcmp(v->desc, w->desc);
749 if (c) {
750 return (c > 0) ? 1 : -1;
751 } else {
752 void *i = v->ptr;
753 void *j = w->ptr;
754 return (i < j) ? -1 : ((i > j) ? 1 : 0);
755 }
756 }
757
758 SWIGRUNTIME void
759 PySwigObject_dealloc(PySwigObject *self)
760 {
761 PyObject_Del(self);
762 }
763
764 SWIGRUNTIME PyTypeObject*
765 PySwigObject_type(void) {
766 static char pyswigobject_type__doc__[] =
767 "Swig object carries a C/C++ instance pointer";
768
769 static PyNumberMethods PySwigObject_as_number = {
770 (binaryfunc)0, /*nb_add*/
771 (binaryfunc)0, /*nb_subtract*/
772 (binaryfunc)0, /*nb_multiply*/
773 (binaryfunc)0, /*nb_divide*/
774 (binaryfunc)0, /*nb_remainder*/
775 (binaryfunc)0, /*nb_divmod*/
776 (ternaryfunc)0,/*nb_power*/
777 (unaryfunc)0, /*nb_negative*/
778 (unaryfunc)0, /*nb_positive*/
779 (unaryfunc)0, /*nb_absolute*/
780 (inquiry)0, /*nb_nonzero*/
781 0, /*nb_invert*/
782 0, /*nb_lshift*/
783 0, /*nb_rshift*/
784 0, /*nb_and*/
785 0, /*nb_xor*/
786 0, /*nb_or*/
787 (coercion)0, /*nb_coerce*/
788 (unaryfunc)PySwigObject_long, /*nb_int*/
789 (unaryfunc)PySwigObject_long, /*nb_long*/
790 (unaryfunc)0, /*nb_float*/
791 (unaryfunc)PySwigObject_oct, /*nb_oct*/
792 (unaryfunc)PySwigObject_hex, /*nb_hex*/
793 #if PY_VERSION_HEX >= 0x02020000
794 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
795 #elif PY_VERSION_HEX >= 0x02000000
796 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
797 #endif
798 };
799
800 static PyTypeObject pyswigobject_type
801 #if !defined(__cplusplus)
802 ;
803 static int type_init = 0;
804 if (!type_init) {
805 PyTypeObject tmp
806 #endif
807 = {
808 PyObject_HEAD_INIT(&PyType_Type)
809 0, /*ob_size*/
810 (char *)"PySwigObject", /*tp_name*/
811 sizeof(PySwigObject), /*tp_basicsize*/
812 0, /*tp_itemsize*/
813 /* methods */
814 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
815 (printfunc)PySwigObject_print, /*tp_print*/
816 (getattrfunc)0, /*tp_getattr*/
817 (setattrfunc)0, /*tp_setattr*/
818 (cmpfunc)PySwigObject_compare, /*tp_compare*/
819 (reprfunc)PySwigObject_repr, /*tp_repr*/
820 &PySwigObject_as_number, /*tp_as_number*/
821 0, /*tp_as_sequence*/
822 0, /*tp_as_mapping*/
823 (hashfunc)0, /*tp_hash*/
824 (ternaryfunc)0, /*tp_call*/
825 (reprfunc)PySwigObject_str, /*tp_str*/
826 /* Space for future expansion */
827 0,0,0,0,
828 pyswigobject_type__doc__, /* Documentation string */
829 #if PY_VERSION_HEX >= 0x02000000
830 0, /* tp_traverse */
831 0, /* tp_clear */
832 #endif
833 #if PY_VERSION_HEX >= 0x02010000
834 0, /* tp_richcompare */
835 0, /* tp_weaklistoffset */
836 #endif
837 #if PY_VERSION_HEX >= 0x02020000
838 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
839 #endif
840 #if PY_VERSION_HEX >= 0x02030000
841 0, /* tp_del */
842 #endif
843 #ifdef COUNT_ALLOCS
844 0,0,0,0 /* tp_alloc -> tp_next */
845 #endif
846 };
847 #if !defined(__cplusplus)
848 pyswigobject_type = tmp;
849 type_init = 1;
850 }
851 #endif
852 return &pyswigobject_type;
853 }
854
855 SWIGRUNTIME PyObject *
856 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
857 {
858 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_type());
859 if (self) {
860 self->ptr = ptr;
861 self->desc = desc;
862 }
863 return (PyObject *)self;
864 }
865
866 SWIGRUNTIMEINLINE void *
867 PySwigObject_AsVoidPtr(PyObject *self)
868 {
869 return ((PySwigObject *)self)->ptr;
870 }
871
872 SWIGRUNTIMEINLINE const char *
873 PySwigObject_GetDesc(PyObject *self)
874 {
875 return ((PySwigObject *)self)->desc;
876 }
877
878 SWIGRUNTIMEINLINE int
879 PySwigObject_Check(PyObject *op) {
880 return ((op)->ob_type == PySwigObject_type())
881 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
882 }
883
884 /* -----------------------------------------------------------------------------
885 * Implements a simple Swig Packed type, and use it instead of string
886 * ----------------------------------------------------------------------------- */
887
888 typedef struct {
889 PyObject_HEAD
890 void *pack;
891 const char *desc;
892 size_t size;
893 } PySwigPacked;
894
895 SWIGRUNTIME int
896 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
897 {
898 char result[SWIG_BUFFER_SIZE];
899 flags = flags;
900 fputs("<Swig Packed ", fp);
901 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
902 fputs("at ", fp);
903 fputs(result, fp);
904 }
905 fputs(v->desc,fp);
906 fputs(">", fp);
907 return 0;
908 }
909
910 SWIGRUNTIME PyObject *
911 PySwigPacked_repr(PySwigPacked *v)
912 {
913 char result[SWIG_BUFFER_SIZE];
914 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
915 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
916 } else {
917 return PyString_FromFormat("<Swig Packed %s>", v->desc);
918 }
919 }
920
921 SWIGRUNTIME PyObject *
922 PySwigPacked_str(PySwigPacked *v)
923 {
924 char result[SWIG_BUFFER_SIZE];
925 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
926 return PyString_FromFormat("%s%s", result, v->desc);
927 } else {
928 return PyString_FromString(v->desc);
929 }
930 }
931
932 SWIGRUNTIME int
933 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
934 {
935 int c = strcmp(v->desc, w->desc);
936 if (c) {
937 return (c > 0) ? 1 : -1;
938 } else {
939 size_t i = v->size;
940 size_t j = w->size;
941 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
942 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
943 }
944 }
945
946 SWIGRUNTIME void
947 PySwigPacked_dealloc(PySwigPacked *self)
948 {
949 free(self->pack);
950 PyObject_Del(self);
951 }
952
953 SWIGRUNTIME PyTypeObject*
954 PySwigPacked_type(void) {
955 static char pyswigpacked_type__doc__[] =
956 "Swig object carries a C/C++ instance pointer";
957 static PyTypeObject pyswigpacked_type
958 #if !defined(__cplusplus)
959 ;
960 static int type_init = 0;
961 if (!type_init) {
962 PyTypeObject tmp
963 #endif
964 = {
965 PyObject_HEAD_INIT(&PyType_Type)
966 0, /*ob_size*/
967 (char *)"PySwigPacked", /*tp_name*/
968 sizeof(PySwigPacked), /*tp_basicsize*/
969 0, /*tp_itemsize*/
970 /* methods */
971 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
972 (printfunc)PySwigPacked_print, /*tp_print*/
973 (getattrfunc)0, /*tp_getattr*/
974 (setattrfunc)0, /*tp_setattr*/
975 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
976 (reprfunc)PySwigPacked_repr, /*tp_repr*/
977 0, /*tp_as_number*/
978 0, /*tp_as_sequence*/
979 0, /*tp_as_mapping*/
980 (hashfunc)0, /*tp_hash*/
981 (ternaryfunc)0, /*tp_call*/
982 (reprfunc)PySwigPacked_str, /*tp_str*/
983 /* Space for future expansion */
984 0,0,0,0,
985 pyswigpacked_type__doc__, /* Documentation string */
986 #if PY_VERSION_HEX >= 0x02000000
987 0, /* tp_traverse */
988 0, /* tp_clear */
989 #endif
990 #if PY_VERSION_HEX >= 0x02010000
991 0, /* tp_richcompare */
992 0, /* tp_weaklistoffset */
993 #endif
994 #if PY_VERSION_HEX >= 0x02020000
995 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
996 #endif
997 #if PY_VERSION_HEX >= 0x02030000
998 0, /* tp_del */
999 #endif
1000 #ifdef COUNT_ALLOCS
1001 0,0,0,0 /* tp_alloc -> tp_next */
1002 #endif
1003 };
1004 #if !defined(__cplusplus)
1005 pyswigpacked_type = tmp;
1006 type_init = 1;
1007 }
1008 #endif
1009 return &pyswigpacked_type;
1010 }
1011
1012 SWIGRUNTIME PyObject *
1013 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
1014 {
1015 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1016 if (self == NULL) {
1017 return NULL;
1018 } else {
1019 void *pack = malloc(size);
1020 if (pack) {
1021 memcpy(pack, ptr, size);
1022 self->pack = pack;
1023 self->desc = desc;
1024 self->size = size;
1025 return (PyObject *) self;
1026 }
1027 return NULL;
1028 }
1029 }
1030
1031 SWIGRUNTIMEINLINE const char *
1032 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1033 {
1034 PySwigPacked *self = (PySwigPacked *)obj;
1035 if (self->size != size) return 0;
1036 memcpy(ptr, self->pack, size);
1037 return self->desc;
1038 }
1039
1040 SWIGRUNTIMEINLINE const char *
1041 PySwigPacked_GetDesc(PyObject *self)
1042 {
1043 return ((PySwigPacked *)self)->desc;
1044 }
1045
1046 SWIGRUNTIMEINLINE int
1047 PySwigPacked_Check(PyObject *op) {
1048 return ((op)->ob_type == PySwigPacked_type())
1049 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1050 }
1051
1052 #else
1053 /* -----------------------------------------------------------------------------
1054 * Use the old Python PyCObject instead of PySwigObject
1055 * ----------------------------------------------------------------------------- */
1056
1057 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1058 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1059 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1060 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1061
1062 #endif
1063
1064 #endif
1065
1066 /* -----------------------------------------------------------------------------
1067 * errors manipulation
1068 * ----------------------------------------------------------------------------- */
1069
1070 SWIGRUNTIME void
1071 SWIG_Python_TypeError(const char *type, PyObject *obj)
1072 {
1073 if (type) {
1074 #if defined(SWIG_COBJECT_TYPES)
1075 if (obj && PySwigObject_Check(obj)) {
1076 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1077 if (otype) {
1078 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1079 type, otype);
1080 return;
1081 }
1082 } else
1083 #endif
1084 {
1085 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1086 if (otype) {
1087 PyObject *str = PyObject_Str(obj);
1088 const char *cstr = str ? PyString_AsString(str) : 0;
1089 if (cstr) {
1090 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1091 type, otype, cstr);
1092 } else {
1093 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1094 type, otype);
1095 }
1096 Py_XDECREF(str);
1097 return;
1098 }
1099 }
1100 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1101 } else {
1102 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1103 }
1104 }
1105
1106 SWIGRUNTIMEINLINE void
1107 SWIG_Python_NullRef(const char *type)
1108 {
1109 if (type) {
1110 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1111 } else {
1112 PyErr_Format(PyExc_TypeError, "null reference was received");
1113 }
1114 }
1115
1116 SWIGRUNTIME int
1117 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1118 {
1119 if (PyErr_Occurred()) {
1120 PyObject *type = 0;
1121 PyObject *value = 0;
1122 PyObject *traceback = 0;
1123 PyErr_Fetch(&type, &value, &traceback);
1124 if (value) {
1125 PyObject *old_str = PyObject_Str(value);
1126 Py_XINCREF(type);
1127 PyErr_Clear();
1128 if (infront) {
1129 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1130 } else {
1131 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1132 }
1133 Py_DECREF(old_str);
1134 }
1135 return 1;
1136 } else {
1137 return 0;
1138 }
1139 }
1140
1141 SWIGRUNTIME int
1142 SWIG_Python_ArgFail(int argnum)
1143 {
1144 if (PyErr_Occurred()) {
1145 /* add information about failing argument */
1146 char mesg[256];
1147 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
1148 return SWIG_Python_AddErrMesg(mesg, 1);
1149 } else {
1150 return 0;
1151 }
1152 }
1153
1154
1155 /* -----------------------------------------------------------------------------
1156 * pointers/data manipulation
1157 * ----------------------------------------------------------------------------- */
1158
1159 /* Convert a pointer value */
1160 SWIGRUNTIME int
1161 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1162 swig_cast_info *tc;
1163 const char *c = 0;
1164 static PyObject *SWIG_this = 0;
1165 int newref = 0;
1166 PyObject *pyobj = 0;
1167 void *vptr;
1168
1169 if (!obj) return 0;
1170 if (obj == Py_None) {
1171 *ptr = 0;
1172 return 0;
1173 }
1174
1175 #ifdef SWIG_COBJECT_TYPES
1176 if (!(PySwigObject_Check(obj))) {
1177 if (!SWIG_this)
1178 SWIG_this = PyString_FromString("this");
1179 pyobj = obj;
1180 obj = PyObject_GetAttr(obj,SWIG_this);
1181 newref = 1;
1182 if (!obj) goto type_error;
1183 if (!PySwigObject_Check(obj)) {
1184 Py_DECREF(obj);
1185 goto type_error;
1186 }
1187 }
1188 vptr = PySwigObject_AsVoidPtr(obj);
1189 c = (const char *) PySwigObject_GetDesc(obj);
1190 if (newref) { Py_DECREF(obj); }
1191 goto type_check;
1192 #else
1193 if (!(PyString_Check(obj))) {
1194 if (!SWIG_this)
1195 SWIG_this = PyString_FromString("this");
1196 pyobj = obj;
1197 obj = PyObject_GetAttr(obj,SWIG_this);
1198 newref = 1;
1199 if (!obj) goto type_error;
1200 if (!PyString_Check(obj)) {
1201 Py_DECREF(obj);
1202 goto type_error;
1203 }
1204 }
1205 c = PyString_AsString(obj);
1206 /* Pointer values must start with leading underscore */
1207 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1208 if (newref) { Py_DECREF(obj); }
1209 if (!c) goto type_error;
1210 #endif
1211
1212 type_check:
1213 if (ty) {
1214 tc = SWIG_TypeCheck(c,ty);
1215 if (!tc) goto type_error;
1216 *ptr = SWIG_TypeCast(tc,vptr);
1217 } else {
1218 *ptr = vptr;
1219 }
1220 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1221 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1222 }
1223 return 0;
1224
1225 type_error:
1226 PyErr_Clear();
1227 if (pyobj && !obj) {
1228 obj = pyobj;
1229 if (PyCFunction_Check(obj)) {
1230 /* here we get the method pointer for callbacks */
1231 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1232 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1233 if (c) {
1234 c = ty ? SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name) : 0;
1235 if (!c) goto type_error;
1236 goto type_check;
1237 }
1238 }
1239 }
1240 if (flags & SWIG_POINTER_EXCEPTION) {
1241 if (ty) {
1242 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1243 } else {
1244 SWIG_Python_TypeError("C/C++ pointer", obj);
1245 }
1246 }
1247 return -1;
1248 }
1249
1250 /* Convert a pointer value, signal an exception on a type mismatch */
1251 SWIGRUNTIME void *
1252 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1253 void *result;
1254 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1255 PyErr_Clear();
1256 if (flags & SWIG_POINTER_EXCEPTION) {
1257 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1258 SWIG_Python_ArgFail(argnum);
1259 }
1260 }
1261 return result;
1262 }
1263
1264 /* Convert a packed value value */
1265 SWIGRUNTIME int
1266 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1267 swig_cast_info *tc;
1268 const char *c = 0;
1269
1270 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1271 c = PySwigPacked_UnpackData(obj, ptr, sz);
1272 #else
1273 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1274 c = PyString_AsString(obj);
1275 /* Pointer values must start with leading underscore */
1276 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1277 #endif
1278 if (!c) goto type_error;
1279 if (ty) {
1280 tc = SWIG_TypeCheck(c,ty);
1281 if (!tc) goto type_error;
1282 }
1283 return 0;
1284
1285 type_error:
1286 PyErr_Clear();
1287 if (flags & SWIG_POINTER_EXCEPTION) {
1288 if (ty) {
1289 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1290 } else {
1291 SWIG_Python_TypeError("C/C++ packed data", obj);
1292 }
1293 }
1294 return -1;
1295 }
1296
1297 /* Create a new array object */
1298 SWIGRUNTIME PyObject *
1299 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1300 PyObject *robj = 0;
1301 if (!type) {
1302 if (!PyErr_Occurred()) {
1303 PyErr_Format(PyExc_TypeError, "Swig: null type passed to NewPointerObj");
1304 }
1305 return robj;
1306 }
1307 if (!ptr) {
1308 Py_INCREF(Py_None);
1309 return Py_None;
1310 }
1311 #ifdef SWIG_COBJECT_TYPES
1312 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1313 #else
1314 {
1315 char result[SWIG_BUFFER_SIZE];
1316 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1317 PyString_FromString(result) : 0;
1318 }
1319 #endif
1320 if (!robj || (robj == Py_None)) return robj;
1321 if (type->clientdata) {
1322 PyObject *inst;
1323 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1324 Py_DECREF(robj);
1325 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1326 Py_DECREF(args);
1327 if (inst) {
1328 if (own) {
1329 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1330 }
1331 robj = inst;
1332 }
1333 }
1334 return robj;
1335 }
1336
1337 SWIGRUNTIME PyObject *
1338 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1339 PyObject *robj = 0;
1340 if (!ptr) {
1341 Py_INCREF(Py_None);
1342 return Py_None;
1343 }
1344 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1345 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1346 #else
1347 {
1348 char result[SWIG_BUFFER_SIZE];
1349 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1350 PyString_FromString(result) : 0;
1351 }
1352 #endif
1353 return robj;
1354 }
1355
1356 /* -----------------------------------------------------------------------------*
1357 * Get type list
1358 * -----------------------------------------------------------------------------*/
1359
1360 #ifdef SWIG_LINK_RUNTIME
1361 void *SWIG_ReturnGlobalTypeList(void *);
1362 #endif
1363
1364 SWIGRUNTIME swig_module_info *
1365 SWIG_Python_GetModule(void) {
1366 static void *type_pointer = (void *)0;
1367 /* first check if module already created */
1368 if (!type_pointer) {
1369 #ifdef SWIG_LINK_RUNTIME
1370 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1371 #else
1372 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1373 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1374 if (PyErr_Occurred()) {
1375 PyErr_Clear();
1376 type_pointer = (void *)0;
1377 }
1378 #endif
1379 }
1380 return (swig_module_info *) type_pointer;
1381 }
1382
1383 #if PY_MAJOR_VERSION < 2
1384 /* PyModule_AddObject function was introduced in Python 2.0. The following function
1385 is copied out of Python/modsupport.c in python version 2.3.4 */
1386 SWIGINTERN int
1387 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
1388 {
1389 PyObject *dict;
1390 if (!PyModule_Check(m)) {
1391 PyErr_SetString(PyExc_TypeError,
1392 "PyModule_AddObject() needs module as first arg");
1393 return -1;
1394 }
1395 if (!o) {
1396 PyErr_SetString(PyExc_TypeError,
1397 "PyModule_AddObject() needs non-NULL value");
1398 return -1;
1399 }
1400
1401 dict = PyModule_GetDict(m);
1402 if (dict == NULL) {
1403 /* Internal error -- modules must have a dict! */
1404 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
1405 PyModule_GetName(m));
1406 return -1;
1407 }
1408 if (PyDict_SetItemString(dict, name, o))
1409 return -1;
1410 Py_DECREF(o);
1411 return 0;
1412 }
1413 #endif
1414
1415 SWIGRUNTIME void
1416 SWIG_Python_SetModule(swig_module_info *swig_module) {
1417 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
1418
1419 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1420 swig_empty_runtime_method_table);
1421 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, NULL);
1422 if (pointer && module) {
1423 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
1424 }
1425 }
1426
1427 #ifdef __cplusplus
1428 }
1429 #endif
1430
1431
1432 /* -------- TYPES TABLE (BEGIN) -------- */
1433
1434 #define SWIGTYPE_p_buffer swig_types[0]
1435 #define SWIGTYPE_p_char swig_types[1]
1436 #define SWIGTYPE_p_form_ops_t swig_types[2]
1437 #define SWIGTYPE_p_int swig_types[3]
1438 #define SWIGTYPE_p_long swig_types[4]
1439 #define SWIGTYPE_p_unsigned_char swig_types[5]
1440 #define SWIGTYPE_p_unsigned_int swig_types[6]
1441 #define SWIGTYPE_p_unsigned_long swig_types[7]
1442 #define SWIGTYPE_p_wxANIHandler swig_types[8]
1443 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
1444 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
1445 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
1446 #define SWIGTYPE_p_wxAppTraits swig_types[12]
1447 #define SWIGTYPE_p_wxArrayString swig_types[13]
1448 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
1449 #define SWIGTYPE_p_wxBitmap swig_types[15]
1450 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
1451 #define SWIGTYPE_p_wxButton swig_types[17]
1452 #define SWIGTYPE_p_wxCURHandler swig_types[18]
1453 #define SWIGTYPE_p_wxCaret swig_types[19]
1454 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
1455 #define SWIGTYPE_p_wxCloseEvent swig_types[21]
1456 #define SWIGTYPE_p_wxColour swig_types[22]
1457 #define SWIGTYPE_p_wxCommandEvent swig_types[23]
1458 #define SWIGTYPE_p_wxContextMenuEvent swig_types[24]
1459 #define SWIGTYPE_p_wxControl swig_types[25]
1460 #define SWIGTYPE_p_wxControlWithItems swig_types[26]
1461 #define SWIGTYPE_p_wxCursor swig_types[27]
1462 #define SWIGTYPE_p_wxDC swig_types[28]
1463 #define SWIGTYPE_p_wxDateEvent swig_types[29]
1464 #define SWIGTYPE_p_wxDateTime swig_types[30]
1465 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
1466 #define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
1467 #define SWIGTYPE_p_wxDuplexMode swig_types[33]
1468 #define SWIGTYPE_p_wxEraseEvent swig_types[34]
1469 #define SWIGTYPE_p_wxEvent swig_types[35]
1470 #define SWIGTYPE_p_wxEventLoop swig_types[36]
1471 #define SWIGTYPE_p_wxEventLoopActivator swig_types[37]
1472 #define SWIGTYPE_p_wxEvtHandler swig_types[38]
1473 #define SWIGTYPE_p_wxFSFile swig_types[39]
1474 #define SWIGTYPE_p_wxFileSystem swig_types[40]
1475 #define SWIGTYPE_p_wxFileSystemHandler swig_types[41]
1476 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
1477 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
1478 #define SWIGTYPE_p_wxFont swig_types[44]
1479 #define SWIGTYPE_p_wxFrame swig_types[45]
1480 #define SWIGTYPE_p_wxGBPosition swig_types[46]
1481 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
1482 #define SWIGTYPE_p_wxGBSpan swig_types[48]
1483 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
1484 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
1485 #define SWIGTYPE_p_wxGridSizer swig_types[51]
1486 #define SWIGTYPE_p_wxICOHandler swig_types[52]
1487 #define SWIGTYPE_p_wxIconizeEvent swig_types[53]
1488 #define SWIGTYPE_p_wxIdleEvent swig_types[54]
1489 #define SWIGTYPE_p_wxImage swig_types[55]
1490 #define SWIGTYPE_p_wxImageHandler swig_types[56]
1491 #define SWIGTYPE_p_wxImageHistogram swig_types[57]
1492 #define SWIGTYPE_p_wxImage_HSVValue swig_types[58]
1493 #define SWIGTYPE_p_wxImage_RGBValue swig_types[59]
1494 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[60]
1495 #define SWIGTYPE_p_wxInitDialogEvent swig_types[61]
1496 #define SWIGTYPE_p_wxInputStream swig_types[62]
1497 #define SWIGTYPE_p_wxInternetFSHandler swig_types[63]
1498 #define SWIGTYPE_p_wxItemContainer swig_types[64]
1499 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1500 #define SWIGTYPE_p_wxKeyEvent swig_types[66]
1501 #define SWIGTYPE_p_wxLayoutConstraints swig_types[67]
1502 #define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
1503 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
1504 #define SWIGTYPE_p_wxMenu swig_types[70]
1505 #define SWIGTYPE_p_wxMenuBar swig_types[71]
1506 #define SWIGTYPE_p_wxMenuBarBase swig_types[72]
1507 #define SWIGTYPE_p_wxMenuEvent swig_types[73]
1508 #define SWIGTYPE_p_wxMenuItem swig_types[74]
1509 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]
1510 #define SWIGTYPE_p_wxMouseEvent swig_types[76]
1511 #define SWIGTYPE_p_wxMoveEvent swig_types[77]
1512 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[78]
1513 #define SWIGTYPE_p_wxNcPaintEvent swig_types[79]
1514 #define SWIGTYPE_p_wxNotifyEvent swig_types[80]
1515 #define SWIGTYPE_p_wxObject swig_types[81]
1516 #define SWIGTYPE_p_wxOutputStream swig_types[82]
1517 #define SWIGTYPE_p_wxPCXHandler swig_types[83]
1518 #define SWIGTYPE_p_wxPNGHandler swig_types[84]
1519 #define SWIGTYPE_p_wxPNMHandler swig_types[85]
1520 #define SWIGTYPE_p_wxPaintEvent swig_types[86]
1521 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[87]
1522 #define SWIGTYPE_p_wxPaperSize swig_types[88]
1523 #define SWIGTYPE_p_wxPoint swig_types[89]
1524 #define SWIGTYPE_p_wxPoint2D swig_types[90]
1525 #define SWIGTYPE_p_wxPropagateOnce swig_types[91]
1526 #define SWIGTYPE_p_wxPropagationDisabler swig_types[92]
1527 #define SWIGTYPE_p_wxPyApp swig_types[93]
1528 #define SWIGTYPE_p_wxPyCommandEvent swig_types[94]
1529 #define SWIGTYPE_p_wxPyDropTarget swig_types[95]
1530 #define SWIGTYPE_p_wxPyEvent swig_types[96]
1531 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[97]
1532 #define SWIGTYPE_p_wxPyImageHandler swig_types[98]
1533 #define SWIGTYPE_p_wxPyInputStream swig_types[99]
1534 #define SWIGTYPE_p_wxPySizer swig_types[100]
1535 #define SWIGTYPE_p_wxPyValidator swig_types[101]
1536 #define SWIGTYPE_p_wxQuantize swig_types[102]
1537 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[103]
1538 #define SWIGTYPE_p_wxRealPoint swig_types[104]
1539 #define SWIGTYPE_p_wxRect swig_types[105]
1540 #define SWIGTYPE_p_wxRegion swig_types[106]
1541 #define SWIGTYPE_p_wxScrollEvent swig_types[107]
1542 #define SWIGTYPE_p_wxScrollWinEvent swig_types[108]
1543 #define SWIGTYPE_p_wxSetCursorEvent swig_types[109]
1544 #define SWIGTYPE_p_wxShowEvent swig_types[110]
1545 #define SWIGTYPE_p_wxSize swig_types[111]
1546 #define SWIGTYPE_p_wxSizeEvent swig_types[112]
1547 #define SWIGTYPE_p_wxSizer swig_types[113]
1548 #define SWIGTYPE_p_wxSizerItem swig_types[114]
1549 #define SWIGTYPE_p_wxStaticBox swig_types[115]
1550 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[116]
1551 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[117]
1552 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[118]
1553 #define SWIGTYPE_p_wxTIFFHandler swig_types[119]
1554 #define SWIGTYPE_p_wxToolTip swig_types[120]
1555 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[121]
1556 #define SWIGTYPE_p_wxValidator swig_types[122]
1557 #define SWIGTYPE_p_wxVisualAttributes swig_types[123]
1558 #define SWIGTYPE_p_wxWindow swig_types[124]
1559 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[125]
1560 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[126]
1561 #define SWIGTYPE_p_wxXPMHandler swig_types[127]
1562 #define SWIGTYPE_p_wxZipFSHandler swig_types[128]
1563 #define SWIGTYPE_ptrdiff_t swig_types[129]
1564 #define SWIGTYPE_std__ptrdiff_t swig_types[130]
1565 #define SWIGTYPE_unsigned_int swig_types[131]
1566 static swig_type_info *swig_types[133];
1567 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
1568 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1569 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1570
1571 /* -------- TYPES TABLE (END) -------- */
1572
1573
1574 /*-----------------------------------------------
1575 @(target):= _core_.so
1576 ------------------------------------------------*/
1577 #define SWIG_init init_core_
1578
1579 #define SWIG_name "_core_"
1580
1581 #include "wx/wxPython/wxPython_int.h"
1582 #include "wx/wxPython/pyclasses.h"
1583
1584
1585 #ifndef wxPyUSE_EXPORT
1586 // Helper functions for dealing with SWIG objects and such. These are
1587 // located here so they know about the SWIG types and functions declared
1588 // in the wrapper code.
1589
1590 #include <wx/hashmap.h>
1591 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1592
1593
1594 // Maintains a hashmap of className to swig_type_info pointers. Given the
1595 // name of a class either looks up the type info in the cache, or scans the
1596 // SWIG tables for it.
1597 extern PyObject* wxPyPtrTypeMap;
1598 static
1599 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1600
1601 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1602
1603 if (typeInfoCache == NULL)
1604 typeInfoCache = new wxPyTypeInfoHashMap;
1605
1606 wxString name(className);
1607 swig_type_info* swigType = (*typeInfoCache)[name];
1608
1609 if (! swigType) {
1610 // it wasn't in the cache, so look it up from SWIG
1611 name.Append(wxT(" *"));
1612 swigType = SWIG_TypeQuery(name.mb_str());
1613
1614 // if it still wasn't found, try looking for a mapped name
1615 if (!swigType) {
1616 PyObject* item;
1617 name = className;
1618
1619 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1620 (char*)(const char*)name.mbc_str())) != NULL) {
1621 name = wxString(PyString_AsString(item), *wxConvCurrent);
1622 name.Append(wxT(" *"));
1623 swigType = SWIG_TypeQuery(name.mb_str());
1624 }
1625 }
1626 if (swigType) {
1627 // and add it to the map if found
1628 (*typeInfoCache)[className] = swigType;
1629 }
1630 }
1631 return swigType;
1632 }
1633
1634
1635 // Check if a class name is a type known to SWIG
1636 bool wxPyCheckSwigType(const wxChar* className) {
1637
1638 swig_type_info* swigType = wxPyFindSwigType(className);
1639 return swigType != NULL;
1640 }
1641
1642
1643 // Given a pointer to a C++ object and a class name, construct a Python proxy
1644 // object for it.
1645 PyObject* wxPyConstructObject(void* ptr,
1646 const wxChar* className,
1647 int setThisOwn) {
1648
1649 swig_type_info* swigType = wxPyFindSwigType(className);
1650 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1651
1652 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1653 }
1654
1655
1656 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1657 // Ensures that the proxy object is of the specified (or derived) type. If
1658 // not able to perform the conversion then a Python exception is set and the
1659 // error should be handled properly in the caller. Returns True on success.
1660 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1661 const wxChar* className) {
1662
1663 swig_type_info* swigType = wxPyFindSwigType(className);
1664 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1665
1666 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1667 }
1668
1669
1670 // Make a SWIGified pointer object suitable for a .this attribute
1671 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1672
1673 PyObject* robj = NULL;
1674
1675 swig_type_info* swigType = wxPyFindSwigType(className);
1676 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1677
1678 #ifdef SWIG_COBJECT_TYPES
1679 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1680 #else
1681 {
1682 char result[1024];
1683 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1684 PyString_FromString(result) : 0;
1685 }
1686 #endif
1687
1688 return robj;
1689 }
1690
1691
1692 // Python's PyInstance_Check does not return True for instances of new-style
1693 // classes. This should get close enough for both new and old classes but I
1694 // should re-evaluate the need for doing instance checks...
1695 bool wxPyInstance_Check(PyObject* obj) {
1696 return PyObject_HasAttrString(obj, "__class__") != 0;
1697 }
1698
1699
1700
1701 // This one checks if the object is an instance of a SWIG proxy class (it has
1702 // a .this attribute, and the .this attribute is a PySwigObject.)
1703 bool wxPySwigInstance_Check(PyObject* obj) {
1704 static PyObject* this_str = NULL;
1705 if (this_str == NULL)
1706 this_str = PyString_FromString("this");
1707
1708 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
1709 if (this_attr) {
1710 bool retval = (PySwigObject_Check(this_attr) != 0);
1711 Py_DECREF(this_attr);
1712 return retval;
1713 }
1714
1715 PyErr_Clear();
1716 return false;
1717 }
1718
1719
1720
1721 // Export a C API in a struct. Other modules will be able to load this from
1722 // the wx._core_ module and will then have safe access to these functions,
1723 // even if they are located in another shared library.
1724 static wxPyCoreAPI API = {
1725
1726 wxPyCheckSwigType,
1727 wxPyConstructObject,
1728 wxPyConvertSwigPtr,
1729 wxPyMakeSwigPtr,
1730
1731 wxPyBeginAllowThreads,
1732 wxPyEndAllowThreads,
1733 wxPyBeginBlockThreads,
1734 wxPyEndBlockThreads,
1735
1736 wxPy_ConvertList,
1737
1738 wxString_in_helper,
1739 Py2wxString,
1740 wx2PyString,
1741
1742 byte_LIST_helper,
1743 int_LIST_helper,
1744 long_LIST_helper,
1745 string_LIST_helper,
1746 wxPoint_LIST_helper,
1747 wxBitmap_LIST_helper,
1748 wxString_LIST_helper,
1749 wxAcceleratorEntry_LIST_helper,
1750
1751 wxSize_helper,
1752 wxPoint_helper,
1753 wxRealPoint_helper,
1754 wxRect_helper,
1755 wxColour_helper,
1756 wxPoint2D_helper,
1757
1758 wxPySimple_typecheck,
1759 wxColour_typecheck,
1760
1761 wxPyCBH_setCallbackInfo,
1762 wxPyCBH_findCallback,
1763 wxPyCBH_callCallback,
1764 wxPyCBH_callCallbackObj,
1765 wxPyCBH_delete,
1766
1767 wxPyMake_wxObject,
1768 wxPyMake_wxSizer,
1769 wxPyPtrTypeMap_Add,
1770 wxPy2int_seq_helper,
1771 wxPy4int_seq_helper,
1772 wxArrayString2PyList_helper,
1773 wxArrayInt2PyList_helper,
1774
1775 wxPyClientData_dtor,
1776 wxPyUserData_dtor,
1777 wxPyOORClientData_dtor,
1778
1779 wxPyCBInputStream_create,
1780 wxPyCBInputStream_copy,
1781
1782 wxPyInstance_Check,
1783 wxPySwigInstance_Check,
1784
1785 wxPyCheckForApp
1786
1787 };
1788
1789 #endif
1790
1791
1792 #if !WXWIN_COMPATIBILITY_2_4
1793 #define wxHIDE_READONLY 0
1794 #endif
1795
1796
1797 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
1798 #define SWIG_From_int PyInt_FromLong
1799 /*@@*/
1800
1801 static const wxString wxPyEmptyString(wxEmptyString);
1802 static wxString wxObject_GetClassName(wxObject *self){
1803 return self->GetClassInfo()->GetClassName();
1804 }
1805 static void wxObject_Destroy(wxObject *self){
1806 delete self;
1807 }
1808
1809 #ifndef __WXMAC__
1810 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1811 #endif
1812
1813
1814 #include <limits.h>
1815
1816
1817 SWIGINTERN int
1818 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1819 const char *errmsg)
1820 {
1821 if (value < min_value) {
1822 if (errmsg) {
1823 PyErr_Format(PyExc_OverflowError,
1824 "value %ld is less than '%s' minimum %ld",
1825 value, errmsg, min_value);
1826 }
1827 return 0;
1828 } else if (value > max_value) {
1829 if (errmsg) {
1830 PyErr_Format(PyExc_OverflowError,
1831 "value %ld is greater than '%s' maximum %ld",
1832 value, errmsg, max_value);
1833 }
1834 return 0;
1835 }
1836 return 1;
1837 }
1838
1839
1840 SWIGINTERN int
1841 SWIG_AsVal_long(PyObject* obj, long* val)
1842 {
1843 if (PyNumber_Check(obj)) {
1844 if (val) *val = PyInt_AsLong(obj);
1845 return 1;
1846 }
1847 else {
1848 SWIG_type_error("number", obj);
1849 }
1850 return 0;
1851 }
1852
1853
1854 #if INT_MAX != LONG_MAX
1855 SWIGINTERN int
1856 SWIG_AsVal_int(PyObject *obj, int *val)
1857 {
1858 const char* errmsg = val ? "int" : (char*)0;
1859 long v;
1860 if (SWIG_AsVal_long(obj, &v)) {
1861 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1862 if (val) *val = static_cast<int >(v);
1863 return 1;
1864 } else {
1865 return 0;
1866 }
1867 } else {
1868 PyErr_Clear();
1869 }
1870 if (val) {
1871 SWIG_type_error(errmsg, obj);
1872 }
1873 return 0;
1874 }
1875 #else
1876 SWIGINTERNINLINE int
1877 SWIG_AsVal_int(PyObject *obj, int *val)
1878 {
1879 return SWIG_AsVal_long(obj,(long*)val);
1880 }
1881 #endif
1882
1883
1884 SWIGINTERNINLINE int
1885 SWIG_As_int(PyObject* obj)
1886 {
1887 int v;
1888 if (!SWIG_AsVal_int(obj, &v)) {
1889 /*
1890 this is needed to make valgrind/purify happier.
1891 */
1892 memset((void*)&v, 0, sizeof(int));
1893 }
1894 return v;
1895 }
1896
1897
1898 SWIGINTERNINLINE int
1899 SWIG_Check_int(PyObject* obj)
1900 {
1901 return SWIG_AsVal_int(obj, (int*)0);
1902 }
1903
1904 static PyObject *wxSize_Get(wxSize *self){
1905 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1906 PyObject* tup = PyTuple_New(2);
1907 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1908 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1909 wxPyEndBlockThreads(blocked);
1910 return tup;
1911 }
1912
1913 SWIGINTERN int
1914 SWIG_AsVal_double(PyObject *obj, double* val)
1915 {
1916 if (PyNumber_Check(obj)) {
1917 if (val) *val = PyFloat_AsDouble(obj);
1918 return 1;
1919 }
1920 else {
1921 SWIG_type_error("number", obj);
1922 }
1923 return 0;
1924 }
1925
1926
1927 SWIGINTERNINLINE double
1928 SWIG_As_double(PyObject* obj)
1929 {
1930 double v;
1931 if (!SWIG_AsVal_double(obj, &v)) {
1932 /*
1933 this is needed to make valgrind/purify happier.
1934 */
1935 memset((void*)&v, 0, sizeof(double));
1936 }
1937 return v;
1938 }
1939
1940
1941 SWIGINTERNINLINE int
1942 SWIG_Check_double(PyObject* obj)
1943 {
1944 return SWIG_AsVal_double(obj, (double*)0);
1945 }
1946
1947
1948 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
1949 #define SWIG_From_double PyFloat_FromDouble
1950 /*@@*/
1951
1952 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1953 self->x = x;
1954 self->y = y;
1955 }
1956 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1957 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1958 PyObject* tup = PyTuple_New(2);
1959 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1960 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1961 wxPyEndBlockThreads(blocked);
1962 return tup;
1963 }
1964
1965 SWIGINTERNINLINE long
1966 SWIG_As_long(PyObject* obj)
1967 {
1968 long v;
1969 if (!SWIG_AsVal_long(obj, &v)) {
1970 /*
1971 this is needed to make valgrind/purify happier.
1972 */
1973 memset((void*)&v, 0, sizeof(long));
1974 }
1975 return v;
1976 }
1977
1978
1979 SWIGINTERNINLINE int
1980 SWIG_Check_long(PyObject* obj)
1981 {
1982 return SWIG_AsVal_long(obj, (long*)0);
1983 }
1984
1985 static void wxPoint_Set(wxPoint *self,long x,long y){
1986 self->x = x;
1987 self->y = y;
1988 }
1989 static PyObject *wxPoint_Get(wxPoint *self){
1990 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1991 PyObject* tup = PyTuple_New(2);
1992 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1993 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1994 wxPyEndBlockThreads(blocked);
1995 return tup;
1996 }
1997 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1998 self->x = x;
1999 self->y = y;
2000 self->width = width;
2001 self->height = height;
2002 }
2003 static PyObject *wxRect_Get(wxRect *self){
2004 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2005 PyObject* tup = PyTuple_New(4);
2006 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2007 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2008 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
2009 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
2010 wxPyEndBlockThreads(blocked);
2011 return tup;
2012 }
2013
2014 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
2015 wxRegion reg1(*r1);
2016 wxRegion reg2(*r2);
2017 wxRect dest(0,0,0,0);
2018 PyObject* obj;
2019
2020 reg1.Intersect(reg2);
2021 dest = reg1.GetBox();
2022
2023 if (dest != wxRect(0,0,0,0)) {
2024 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2025 wxRect* newRect = new wxRect(dest);
2026 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
2027 wxPyEndBlockThreads(blocked);
2028 return obj;
2029 }
2030 Py_INCREF(Py_None);
2031 return Py_None;
2032 }
2033
2034
2035 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
2036 PyObject* o2;
2037 PyObject* o3;
2038
2039 if (!target) {
2040 target = o;
2041 } else if (target == Py_None) {
2042 Py_DECREF(Py_None);
2043 target = o;
2044 } else {
2045 if (!PyTuple_Check(target)) {
2046 o2 = target;
2047 target = PyTuple_New(1);
2048 PyTuple_SetItem(target, 0, o2);
2049 }
2050 o3 = PyTuple_New(1);
2051 PyTuple_SetItem(o3, 0, o);
2052
2053 o2 = target;
2054 target = PySequence_Concat(o2, o3);
2055 Py_DECREF(o2);
2056 Py_DECREF(o3);
2057 }
2058 return target;
2059 }
2060
2061
2062 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
2063 self->m_x = x;
2064 self->m_y = y;
2065 }
2066 static PyObject *wxPoint2D_Get(wxPoint2D *self){
2067 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2068 PyObject* tup = PyTuple_New(2);
2069 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
2070 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
2071 wxPyEndBlockThreads(blocked);
2072 return tup;
2073 }
2074
2075 #include "wx/wxPython/pyistream.h"
2076
2077 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
2078 wxInputStream* wxis = wxPyCBInputStream::create(p);
2079 if (wxis)
2080 return new wxPyInputStream(wxis);
2081 else
2082 return NULL;
2083 }
2084
2085 SWIGINTERNINLINE PyObject*
2086 SWIG_From_char(char c)
2087 {
2088 return PyString_FromStringAndSize(&c,1);
2089 }
2090
2091
2092 SWIGINTERNINLINE PyObject*
2093 SWIG_From_unsigned_SS_long(unsigned long value)
2094 {
2095 return (value > LONG_MAX) ?
2096 PyLong_FromUnsignedLong(value)
2097 : PyInt_FromLong(static_cast<long >(value));
2098 }
2099
2100
2101 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
2102 SWIGINTERN int
2103 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
2104 {
2105 static swig_type_info* pchar_info = 0;
2106 char* vptr = 0;
2107 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
2108 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
2109 if (cptr) *cptr = vptr;
2110 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
2111 return SWIG_OLDOBJ;
2112 } else {
2113 PyErr_Clear();
2114 if (PyString_Check(obj)) {
2115 if (cptr) {
2116 *cptr = PyString_AS_STRING(obj);
2117 if (psize) {
2118 *psize = PyString_GET_SIZE(obj) + 1;
2119 }
2120 }
2121 return SWIG_PYSTR;
2122 }
2123 }
2124 if (cptr) {
2125 SWIG_type_error("char *", obj);
2126 }
2127 return 0;
2128 }
2129
2130
2131 SWIGINTERN int
2132 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2133 {
2134 char* cptr; size_t csize;
2135 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2136 /* in C you can do:
2137
2138 char x[5] = "hello";
2139
2140 ie, assing the array using an extra '0' char.
2141 */
2142 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2143 if (csize <= size) {
2144 if (val) {
2145 if (csize) memcpy(val, cptr, csize);
2146 if (csize < size) memset(val + csize, 0, size - csize);
2147 }
2148 return 1;
2149 }
2150 }
2151 if (val) {
2152 PyErr_Format(PyExc_TypeError,
2153 "a char array of maximum size %lu is expected",
2154 (unsigned long) size);
2155 }
2156 return 0;
2157 }
2158
2159
2160 SWIGINTERN int
2161 SWIG_AsVal_char(PyObject *obj, char *val)
2162 {
2163 const char* errmsg = val ? "char" : (char*)0;
2164 long v;
2165 if (SWIG_AsVal_long(obj, &v)) {
2166 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2167 if (val) *val = static_cast<char >(v);
2168 return 1;
2169 } else {
2170 return 0;
2171 }
2172 } else {
2173 PyErr_Clear();
2174 return SWIG_AsCharArray(obj, val, 1);
2175 }
2176 }
2177
2178
2179 SWIGINTERNINLINE char
2180 SWIG_As_char(PyObject* obj)
2181 {
2182 char v;
2183 if (!SWIG_AsVal_char(obj, &v)) {
2184 /*
2185 this is needed to make valgrind/purify happier.
2186 */
2187 memset((void*)&v, 0, sizeof(char));
2188 }
2189 return v;
2190 }
2191
2192
2193 SWIGINTERNINLINE int
2194 SWIG_Check_char(PyObject* obj)
2195 {
2196 return SWIG_AsVal_char(obj, (char*)0);
2197 }
2198
2199
2200 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2201 #define SWIG_From_long PyInt_FromLong
2202 /*@@*/
2203
2204 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2205 // We use only strings for the streams, not unicode
2206 PyObject* str = PyObject_Str(obj);
2207 if (! str) {
2208 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2209 return;
2210 }
2211 self->Write(PyString_AS_STRING(str),
2212 PyString_GET_SIZE(str));
2213 Py_DECREF(str);
2214 }
2215
2216 #include "wx/wxPython/pyistream.h"
2217
2218
2219 class wxPyFileSystemHandler : public wxFileSystemHandler
2220 {
2221 public:
2222 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2223
2224 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2225 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2226 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2227 DEC_PYCALLBACK_STRING__pure(FindNext);
2228
2229 wxString GetProtocol(const wxString& location) {
2230 return wxFileSystemHandler::GetProtocol(location);
2231 }
2232
2233 wxString GetLeftLocation(const wxString& location) {
2234 return wxFileSystemHandler::GetLeftLocation(location);
2235 }
2236
2237 wxString GetAnchor(const wxString& location) {
2238 return wxFileSystemHandler::GetAnchor(location);
2239 }
2240
2241 wxString GetRightLocation(const wxString& location) {
2242 return wxFileSystemHandler::GetRightLocation(location);
2243 }
2244
2245 wxString GetMimeTypeFromExt(const wxString& location) {
2246 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2247 }
2248
2249 PYPRIVATE;
2250 };
2251
2252
2253 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2254 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2255 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2256 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2257
2258
2259 SWIGINTERN int
2260 SWIG_AsVal_bool(PyObject *obj, bool *val)
2261 {
2262 if (obj == Py_True) {
2263 if (val) *val = true;
2264 return 1;
2265 }
2266 if (obj == Py_False) {
2267 if (val) *val = false;
2268 return 1;
2269 }
2270 int res = 0;
2271 if (SWIG_AsVal_int(obj, &res)) {
2272 if (val) *val = res ? true : false;
2273 return 1;
2274 } else {
2275 PyErr_Clear();
2276 }
2277 if (val) {
2278 SWIG_type_error("bool", obj);
2279 }
2280 return 0;
2281 }
2282
2283
2284 SWIGINTERNINLINE bool
2285 SWIG_As_bool(PyObject* obj)
2286 {
2287 bool v;
2288 if (!SWIG_AsVal_bool(obj, &v)) {
2289 /*
2290 this is needed to make valgrind/purify happier.
2291 */
2292 memset((void*)&v, 0, sizeof(bool));
2293 }
2294 return v;
2295 }
2296
2297
2298 SWIGINTERNINLINE int
2299 SWIG_Check_bool(PyObject* obj)
2300 {
2301 return SWIG_AsVal_bool(obj, (bool*)0);
2302 }
2303
2304 static wxString wxFileSystem_URLToFileName(wxString const &url){
2305 wxFileName fname = wxFileSystem::URLToFileName(url);
2306 return fname.GetFullPath();
2307 }
2308
2309 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2310 wxImage& image,
2311 long type) {
2312 wxMemoryFSHandler::AddFile(filename, image, type);
2313 }
2314
2315 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2316 const wxBitmap& bitmap,
2317 long type) {
2318 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2319 }
2320
2321 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2322 PyObject* data) {
2323 if (! PyString_Check(data)) {
2324 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2325 "Expected string object"));
2326 return;
2327 }
2328
2329 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2330 void* ptr = (void*)PyString_AsString(data);
2331 size_t size = PyString_Size(data);
2332 wxPyEndBlockThreads(blocked);
2333
2334 wxMemoryFSHandler::AddFile(filename, ptr, size);
2335 }
2336
2337
2338 #include "wx/wxPython/pyistream.h"
2339
2340
2341 SWIGINTERN int
2342 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2343 {
2344 long v = 0;
2345 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2346 SWIG_type_error("unsigned number", obj);
2347 }
2348 else if (val)
2349 *val = (unsigned long)v;
2350 return 1;
2351 }
2352
2353
2354 SWIGINTERNINLINE int
2355 SWIG_CheckUnsignedLongInRange(unsigned long value,
2356 unsigned long max_value,
2357 const char *errmsg)
2358 {
2359 if (value > max_value) {
2360 if (errmsg) {
2361 PyErr_Format(PyExc_OverflowError,
2362 "value %lu is greater than '%s' minimum %lu",
2363 value, errmsg, max_value);
2364 }
2365 return 0;
2366 }
2367 return 1;
2368 }
2369
2370
2371 SWIGINTERN int
2372 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2373 {
2374 const char* errmsg = val ? "unsigned char" : (char*)0;
2375 unsigned long v;
2376 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2377 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2378 if (val) *val = static_cast<unsigned char >(v);
2379 return 1;
2380 } else {
2381 return 0;
2382 }
2383 } else {
2384 PyErr_Clear();
2385 }
2386 if (val) {
2387 SWIG_type_error(errmsg, obj);
2388 }
2389 return 0;
2390 }
2391
2392
2393 SWIGINTERNINLINE unsigned char
2394 SWIG_As_unsigned_SS_char(PyObject* obj)
2395 {
2396 unsigned char v;
2397 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2398 /*
2399 this is needed to make valgrind/purify happier.
2400 */
2401 memset((void*)&v, 0, sizeof(unsigned char));
2402 }
2403 return v;
2404 }
2405
2406
2407 SWIGINTERNINLINE int
2408 SWIG_Check_unsigned_SS_char(PyObject* obj)
2409 {
2410 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2411 }
2412
2413
2414 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2415 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2416 /*@@*/
2417
2418
2419
2420 SWIGINTERNINLINE unsigned long
2421 SWIG_As_unsigned_SS_long(PyObject* obj)
2422 {
2423 unsigned long v;
2424 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2425 /*
2426 this is needed to make valgrind/purify happier.
2427 */
2428 memset((void*)&v, 0, sizeof(unsigned long));
2429 }
2430 return v;
2431 }
2432
2433
2434 SWIGINTERNINLINE int
2435 SWIG_Check_unsigned_SS_long(PyObject* obj)
2436 {
2437 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2438 }
2439
2440 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2441 wxImageHistogramEntry e = (*self)[key];
2442 return e.value;
2443 }
2444 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
2445 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2446 wxImageHistogramEntry e = (*self)[key];
2447 return e.value;
2448 }
2449 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2450 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2451 colour.Green(),
2452 colour.Blue());
2453 wxImageHistogramEntry e = (*self)[key];
2454 return e.value;
2455 }
2456
2457 typedef unsigned char* buffer;
2458
2459
2460 // Pull the nested class out to the top level for SWIG's sake
2461 #define wxImage_RGBValue wxImage::RGBValue
2462 #define wxImage_HSVValue wxImage::HSVValue
2463
2464 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2465 if (width > 0 && height > 0)
2466 return new wxImage(width, height, clear);
2467 else
2468 return new wxImage;
2469 }
2470 static wxImage *new_wxImage(wxBitmap const &bitmap){
2471 return new wxImage(bitmap.ConvertToImage());
2472 }
2473 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2474 if (DATASIZE != width*height*3) {
2475 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2476 return NULL;
2477 }
2478
2479 // Copy the source data so the wxImage can clean it up later
2480 buffer copy = (buffer)malloc(DATASIZE);
2481 if (copy == NULL) {
2482 wxPyBLOCK_THREADS(PyErr_NoMemory());
2483 return NULL;
2484 }
2485 memcpy(copy, data, DATASIZE);
2486 return new wxImage(width, height, copy, false);
2487 }
2488 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2489 if (DATASIZE != width*height*3) {
2490 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2491 return NULL;
2492 }
2493 if (ALPHASIZE != width*height) {
2494 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2495 return NULL;
2496 }
2497
2498 // Copy the source data so the wxImage can clean it up later
2499 buffer dcopy = (buffer)malloc(DATASIZE);
2500 if (dcopy == NULL) {
2501 wxPyBLOCK_THREADS(PyErr_NoMemory());
2502 return NULL;
2503 }
2504 memcpy(dcopy, data, DATASIZE);
2505
2506 buffer acopy = (buffer)malloc(ALPHASIZE);
2507 if (acopy == NULL) {
2508 wxPyBLOCK_THREADS(PyErr_NoMemory());
2509 return NULL;
2510 }
2511 memcpy(acopy, alpha, ALPHASIZE);
2512
2513 return new wxImage(width, height, dcopy, acopy, false);
2514 }
2515 static wxSize wxImage_GetSize(wxImage *self){
2516 wxSize size(self->GetWidth(), self->GetHeight());
2517 return size;
2518 }
2519 static PyObject *wxImage_GetData(wxImage *self){
2520 buffer data = self->GetData();
2521 int len = self->GetWidth() * self->GetHeight() * 3;
2522 PyObject* rv;
2523 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2524 return rv;
2525 }
2526 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2527 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2528 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2529 return;
2530 }
2531 buffer copy = (buffer)malloc(DATASIZE);
2532 if (copy == NULL) {
2533 wxPyBLOCK_THREADS(PyErr_NoMemory());
2534 return;
2535 }
2536 memcpy(copy, data, DATASIZE);
2537 self->SetData(copy, false);
2538 // wxImage takes ownership of copy...
2539 }
2540 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2541 buffer data = self->GetData();
2542 int len = self->GetWidth() * self->GetHeight() * 3;
2543 PyObject* rv;
2544 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2545 return rv;
2546 }
2547 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2548 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2549 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2550 return;
2551 }
2552 self->SetData(data, true);
2553 }
2554 static PyObject *wxImage_GetAlphaData(wxImage *self){
2555 buffer data = self->GetAlpha();
2556 if (! data) {
2557 RETURN_NONE();
2558 } else {
2559 int len = self->GetWidth() * self->GetHeight();
2560 PyObject* rv;
2561 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2562 return rv;
2563 }
2564 }
2565 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2566 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2567 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2568 return;
2569 }
2570 buffer acopy = (buffer)malloc(ALPHASIZE);
2571 if (acopy == NULL) {
2572 wxPyBLOCK_THREADS(PyErr_NoMemory());
2573 return;
2574 }
2575 memcpy(acopy, alpha, ALPHASIZE);
2576 self->SetAlpha(acopy, false);
2577 // wxImage takes ownership of acopy...
2578 }
2579 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2580 buffer data = self->GetAlpha();
2581 int len = self->GetWidth() * self->GetHeight();
2582 PyObject* rv;
2583 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2584 return rv;
2585 }
2586 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2587 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2588 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2589 return;
2590 }
2591 self->SetAlpha(alpha, true);
2592 }
2593 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2594 wxBitmap bitmap(*self, depth);
2595 return bitmap;
2596 }
2597 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
2598 wxImage mono = self->ConvertToMono( red, green, blue );
2599 wxBitmap bitmap( mono, 1 );
2600 return bitmap;
2601 }
2602 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2603 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2604 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2605 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2606 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2607 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2608 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2609 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2610 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2611 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2612 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2613 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2614 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2615 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2616 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2617
2618 #include <wx/quantize.h>
2619
2620 static bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2621 return wxQuantize::Quantize(src, dest,
2622 //NULL, // palette
2623 desiredNoColours,
2624 NULL, // eightBitData
2625 flags);
2626 }
2627 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2628 if (PyCallable_Check(func)) {
2629 self->Connect(id, lastId, eventType,
2630 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2631 new wxPyCallback(func));
2632 }
2633 else if (func == Py_None) {
2634 self->Disconnect(id, lastId, eventType,
2635 (wxObjectEventFunction)
2636 &wxPyCallback::EventThunker);
2637 }
2638 else {
2639 wxPyBLOCK_THREADS(
2640 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2641 }
2642 }
2643 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2644 return self->Disconnect(id, lastId, eventType,
2645 (wxObjectEventFunction)
2646 &wxPyCallback::EventThunker);
2647 }
2648 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2649 if (_self && _self != Py_None) {
2650 self->SetClientObject(new wxPyOORClientData(_self, incref));
2651 }
2652 else {
2653 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2654 if (data) {
2655 self->SetClientObject(NULL); // This will delete it too
2656 }
2657 }
2658 }
2659
2660 #if ! wxUSE_HOTKEY
2661 #define wxEVT_HOTKEY -9999
2662 #endif
2663
2664
2665 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2666 #if wxUSE_UNICODE
2667 return self->GetUnicodeKey();
2668 #else
2669 return 0;
2670 #endif
2671 }
2672
2673 #if UINT_MAX < LONG_MAX
2674 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2675 #define SWIG_From_unsigned_SS_int SWIG_From_long
2676 /*@@*/
2677 #else
2678 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2679 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2680 /*@@*/
2681 #endif
2682
2683
2684 #if UINT_MAX != ULONG_MAX
2685 SWIGINTERN int
2686 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2687 {
2688 const char* errmsg = val ? "unsigned int" : (char*)0;
2689 unsigned long v;
2690 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2691 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2692 if (val) *val = static_cast<unsigned int >(v);
2693 return 1;
2694 }
2695 } else {
2696 PyErr_Clear();
2697 }
2698 if (val) {
2699 SWIG_type_error(errmsg, obj);
2700 }
2701 return 0;
2702 }
2703 #else
2704 SWIGINTERNINLINE unsigned int
2705 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2706 {
2707 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2708 }
2709 #endif
2710
2711
2712 SWIGINTERNINLINE unsigned int
2713 SWIG_As_unsigned_SS_int(PyObject* obj)
2714 {
2715 unsigned int v;
2716 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2717 /*
2718 this is needed to make valgrind/purify happier.
2719 */
2720 memset((void*)&v, 0, sizeof(unsigned int));
2721 }
2722 return v;
2723 }
2724
2725
2726 SWIGINTERNINLINE int
2727 SWIG_Check_unsigned_SS_int(PyObject* obj)
2728 {
2729 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2730 }
2731
2732 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2733 self->m_size = size;
2734 }
2735 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2736 int count = self->GetNumberOfFiles();
2737 wxString* files = self->GetFiles();
2738 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2739 PyObject* list = PyList_New(count);
2740
2741 if (!list) {
2742 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2743 wxPyEndBlockThreads(blocked);
2744 return NULL;
2745 }
2746
2747 for (int i=0; i<count; i++) {
2748 PyList_SetItem(list, i, wx2PyString(files[i]));
2749 }
2750 wxPyEndBlockThreads(blocked);
2751 return list;
2752 }
2753
2754
2755 static wxPyApp *new_wxPyApp(){
2756 wxPythonApp = new wxPyApp();
2757 return wxPythonApp;
2758 }
2759 static int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2760
2761 void wxApp_CleanUp() {
2762 __wxPyCleanup();
2763 }
2764
2765
2766 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2767
2768
2769 SWIGINTERNINLINE int
2770 SWIG_AsCharPtr(PyObject *obj, char **val)
2771 {
2772 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2773 return 1;
2774 }
2775 if (val) {
2776 PyErr_Clear();
2777 SWIG_type_error("char *", obj);
2778 }
2779 return 0;
2780 }
2781
2782
2783 SWIGINTERN PyObject *
2784 SWIG_FromCharPtr(const char* cptr)
2785 {
2786 if (cptr) {
2787 size_t size = strlen(cptr);
2788 if (size > INT_MAX) {
2789 return SWIG_NewPointerObj(const_cast<char* >(cptr),
2790 SWIG_TypeQuery("char *"), 0);
2791 } else {
2792 if (size != 0) {
2793 return PyString_FromStringAndSize(cptr, size);
2794 } else {
2795 return PyString_FromString(cptr);
2796 }
2797 }
2798 }
2799 Py_INCREF(Py_None);
2800 return Py_None;
2801 }
2802
2803
2804 #if 0 // #ifdef __WXMAC__
2805
2806 // A dummy class that raises an exception if used...
2807 class wxEventLoop
2808 {
2809 public:
2810 wxEventLoop() { wxPyRaiseNotImplemented(); }
2811 int Run() { return 0; }
2812 void Exit(int rc = 0) {}
2813 bool Pending() const { return false; }
2814 bool Dispatch() { return false; }
2815 bool IsRunning() const { return false; }
2816 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2817 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2818 };
2819
2820 #else
2821
2822 #include <wx/evtloop.h>
2823
2824 #endif
2825
2826
2827
2828 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2829 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2830 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2831 static PyObject *wxWindow_GetChildren(wxWindow *self){
2832 wxWindowList& list = self->GetChildren();
2833 return wxPy_ConvertList(&list);
2834 }
2835 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2836 #if wxUSE_HOTKEY
2837 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2838 #else
2839 return false;
2840 #endif
2841 }
2842 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2843
2844
2845
2846 return false;
2847
2848 }
2849 static long wxWindow_GetHandle(wxWindow *self){
2850 return wxPyGetWinHandle(self);
2851 }
2852 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2853 self->AssociateHandle((WXWidget)handle);
2854 }
2855 static void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
2856
2857 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2858 return wxWindow::FindWindowById(id, parent);
2859 }
2860
2861 wxWindow* wxFindWindowByName( const wxString& name,
2862 const wxWindow *parent = NULL ) {
2863 return wxWindow::FindWindowByName(name, parent);
2864 }
2865
2866 wxWindow* wxFindWindowByLabel( const wxString& label,
2867 const wxWindow *parent = NULL ) {
2868 return wxWindow::FindWindowByLabel(label, parent);
2869 }
2870
2871
2872 #ifdef __WXMSW__
2873 #include <wx/msw/private.h> // to get wxGetWindowId
2874 #endif
2875
2876
2877 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2878 #ifdef __WXMSW__
2879 WXHWND hWnd = (WXHWND)_hWnd;
2880 long id = wxGetWindowId(hWnd);
2881 wxWindow* win = new wxWindow;
2882 if (parent)
2883 parent->AddChild(win);
2884 win->SetEventHandler(win);
2885 win->SetHWND(hWnd);
2886 win->SetId(id);
2887 win->SubclassWin(hWnd);
2888 win->AdoptAttributesFromHWND();
2889 win->SetupColours();
2890 return win;
2891 #else
2892 wxPyRaiseNotImplemented();
2893 return NULL;
2894 #endif
2895 }
2896
2897
2898 PyObject* GetTopLevelWindows() {
2899 return wxPy_ConvertList(&wxTopLevelWindows);
2900 }
2901
2902
2903 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2904 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2905 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2906
2907 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2908
2909 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2910 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2911 wxMenuItemList& list = self->GetMenuItems();
2912 return wxPy_ConvertList(&list);
2913 }
2914 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2915 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2916 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2917 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2918 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2919 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2920 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
2921 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2922 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2923 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2924 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2925 static int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
2926 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2927 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2928 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2929 static const wxString wxPyControlNameStr(wxControlNameStr);
2930 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2931 if (clientData) {
2932 wxPyClientData* data = new wxPyClientData(clientData);
2933 return self->Append(item, data);
2934 } else
2935 return self->Append(item);
2936 }
2937 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2938 if (clientData) {
2939 wxPyClientData* data = new wxPyClientData(clientData);
2940 return self->Insert(item, pos, data);
2941 } else
2942 return self->Insert(item, pos);
2943 }
2944 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2945 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2946 if (data) {
2947 Py_INCREF(data->m_obj);
2948 return data->m_obj;
2949 } else {
2950 Py_INCREF(Py_None);
2951 return Py_None;
2952 }
2953 }
2954 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2955 wxPyClientData* data = new wxPyClientData(clientData);
2956 self->SetClientObject(n, data);
2957 }
2958
2959
2960 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2961 wxPyUserData* data = NULL;
2962 if ( userData ) {
2963 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2964 data = new wxPyUserData(userData);
2965 wxPyEndBlockThreads(blocked);
2966 }
2967 return new wxSizerItem(window, proportion, flag, border, data);
2968 }
2969 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2970 wxPyUserData* data = NULL;
2971 if ( userData ) {
2972 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2973 data = new wxPyUserData(userData);
2974 wxPyEndBlockThreads(blocked);
2975 }
2976 return new wxSizerItem(width, height, proportion, flag, border, data);
2977 }
2978 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2979 wxPyUserData* data = NULL;
2980 if ( userData ) {
2981 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2982 data = new wxPyUserData(userData);
2983 wxPyEndBlockThreads(blocked);
2984 }
2985 return new wxSizerItem(sizer, proportion, flag, border, data);
2986 }
2987
2988 #include <float.h>
2989 SWIGINTERN int
2990 SWIG_CheckDoubleInRange(double value, double min_value,
2991 double max_value, const char* errmsg)
2992 {
2993 if (value < min_value) {
2994 if (errmsg) {
2995 PyErr_Format(PyExc_OverflowError,
2996 "value %g is less than %s minimum %g",
2997 value, errmsg, min_value);
2998 }
2999 return 0;
3000 } else if (value > max_value) {
3001 if (errmsg) {
3002 PyErr_Format(PyExc_OverflowError,
3003 "value %g is greater than %s maximum %g",
3004 value, errmsg, max_value);
3005 }
3006 return 0;
3007 }
3008 return 1;
3009 }
3010
3011
3012 SWIGINTERN int
3013 SWIG_AsVal_float(PyObject *obj, float *val)
3014 {
3015 const char* errmsg = val ? "float" : (char*)0;
3016 double v;
3017 if (SWIG_AsVal_double(obj, &v)) {
3018 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
3019 if (val) *val = static_cast<float >(v);
3020 return 1;
3021 } else {
3022 return 0;
3023 }
3024 } else {
3025 PyErr_Clear();
3026 }
3027 if (val) {
3028 SWIG_type_error(errmsg, obj);
3029 }
3030 return 0;
3031 }
3032
3033
3034 SWIGINTERNINLINE float
3035 SWIG_As_float(PyObject* obj)
3036 {
3037 float v;
3038 if (!SWIG_AsVal_float(obj, &v)) {
3039 /*
3040 this is needed to make valgrind/purify happier.
3041 */
3042 memset((void*)&v, 0, sizeof(float));
3043 }
3044 return v;
3045 }
3046
3047
3048 SWIGINTERNINLINE int
3049 SWIG_Check_float(PyObject* obj)
3050 {
3051 return SWIG_AsVal_float(obj, (float*)0);
3052 }
3053
3054
3055 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
3056 #define SWIG_From_float PyFloat_FromDouble
3057 /*@@*/
3058
3059 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3060 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3061 if (data) {
3062 Py_INCREF(data->m_obj);
3063 return data->m_obj;
3064 } else {
3065 Py_INCREF(Py_None);
3066 return Py_None;
3067 }
3068 }
3069 static void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3070 wxPyUserData* data = NULL;
3071 if ( userData ) {
3072 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3073 data = new wxPyUserData(userData);
3074 wxPyEndBlockThreads(blocked);
3075 }
3076 self->SetUserData(data);
3077 }
3078
3079 // Figure out the type of the sizer item
3080
3081 struct wxPySizerItemInfo {
3082 wxPySizerItemInfo()
3083 : window(NULL), sizer(NULL), gotSize(false),
3084 size(wxDefaultSize), gotPos(false), pos(-1)
3085 {}
3086
3087 wxWindow* window;
3088 wxSizer* sizer;
3089 bool gotSize;
3090 wxSize size;
3091 bool gotPos;
3092 int pos;
3093 };
3094
3095 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
3096
3097 wxPySizerItemInfo info;
3098 wxSize size;
3099 wxSize* sizePtr = &size;
3100
3101 // Find out what the type of the item is
3102 // try wxWindow
3103 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
3104 PyErr_Clear();
3105 info.window = NULL;
3106
3107 // try wxSizer
3108 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
3109 PyErr_Clear();
3110 info.sizer = NULL;
3111
3112 // try wxSize or (w,h)
3113 if ( checkSize && wxSize_helper(item, &sizePtr)) {
3114 info.size = *sizePtr;
3115 info.gotSize = true;
3116 }
3117
3118 // or a single int
3119 if (checkIdx && PyInt_Check(item)) {
3120 info.pos = PyInt_AsLong(item);
3121 info.gotPos = true;
3122 }
3123 }
3124 }
3125
3126 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3127 // no expected type, figure out what kind of error message to generate
3128 if ( !checkSize && !checkIdx )
3129 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3130 else if ( checkSize && !checkIdx )
3131 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3132 else if ( !checkSize && checkIdx)
3133 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3134 else
3135 // can this one happen?
3136 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3137 }
3138
3139 return info;
3140 }
3141
3142 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3143 if (!self->GetClientObject())
3144 self->SetClientObject(new wxPyOORClientData(_self));
3145 }
3146 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3147
3148 wxPyUserData* data = NULL;
3149 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3150 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3151 if ( userData && (info.window || info.sizer || info.gotSize) )
3152 data = new wxPyUserData(userData);
3153 wxPyEndBlockThreads(blocked);
3154
3155 // Now call the real Add method if a valid item type was found
3156 if ( info.window )
3157 return self->Add(info.window, proportion, flag, border, data);
3158 else if ( info.sizer )
3159 return self->Add(info.sizer, proportion, flag, border, data);
3160 else if (info.gotSize)
3161 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3162 proportion, flag, border, data);
3163 else
3164 return NULL;
3165 }
3166 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3167
3168 wxPyUserData* data = NULL;
3169 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3170 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3171 if ( userData && (info.window || info.sizer || info.gotSize) )
3172 data = new wxPyUserData(userData);
3173 wxPyEndBlockThreads(blocked);
3174
3175 // Now call the real Insert method if a valid item type was found
3176 if ( info.window )
3177 return self->Insert(before, info.window, proportion, flag, border, data);
3178 else if ( info.sizer )
3179 return self->Insert(before, info.sizer, proportion, flag, border, data);
3180 else if (info.gotSize)
3181 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3182 proportion, flag, border, data);
3183 else
3184 return NULL;
3185 }
3186 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3187
3188 wxPyUserData* data = NULL;
3189 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3190 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3191 if ( userData && (info.window || info.sizer || info.gotSize) )
3192 data = new wxPyUserData(userData);
3193 wxPyEndBlockThreads(blocked);
3194
3195 // Now call the real Prepend method if a valid item type was found
3196 if ( info.window )
3197 return self->Prepend(info.window, proportion, flag, border, data);
3198 else if ( info.sizer )
3199 return self->Prepend(info.sizer, proportion, flag, border, data);
3200 else if (info.gotSize)
3201 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3202 proportion, flag, border, data);
3203 else
3204 return NULL;
3205 }
3206 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3207 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3208 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3209 wxPyEndBlockThreads(blocked);
3210 if ( info.window )
3211 return self->Remove(info.window);
3212 else if ( info.sizer )
3213 return self->Remove(info.sizer);
3214 else if ( info.gotPos )
3215 return self->Remove(info.pos);
3216 else
3217 return false;
3218 }
3219 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3220 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3221 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3222 wxPyEndBlockThreads(blocked);
3223 if ( info.window )
3224 return self->Detach(info.window);
3225 else if ( info.sizer )
3226 return self->Detach(info.sizer);
3227 else if ( info.gotPos )
3228 return self->Detach(info.pos);
3229 else
3230 return false;
3231 }
3232 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3233 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3234 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3235 wxPyEndBlockThreads(blocked);
3236 if ( info.window )
3237 return self->GetItem(info.window);
3238 else if ( info.sizer )
3239 return self->GetItem(info.sizer);
3240 else if ( info.gotPos )
3241 return self->GetItem(info.pos);
3242 else
3243 return NULL;
3244 }
3245 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3246 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3247 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3248 wxPyEndBlockThreads(blocked);
3249 if ( info.window )
3250 self->SetItemMinSize(info.window, size);
3251 else if ( info.sizer )
3252 self->SetItemMinSize(info.sizer, size);
3253 else if ( info.gotPos )
3254 self->SetItemMinSize(info.pos, size);
3255 }
3256 static PyObject *wxSizer_GetChildren(wxSizer *self){
3257 wxSizerItemList& list = self->GetChildren();
3258 return wxPy_ConvertList(&list);
3259 }
3260 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3261 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3262 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3263 wxPyEndBlockThreads(blocked);
3264 if ( info.window )
3265 return self->Show(info.window, show, recursive);
3266 else if ( info.sizer )
3267 return self->Show(info.sizer, show, recursive);
3268 else if ( info.gotPos )
3269 return self->Show(info.pos, show);
3270 else
3271 return false;
3272 }
3273 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3274 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3275 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3276 wxPyEndBlockThreads(blocked);
3277 if ( info.window )
3278 return self->IsShown(info.window);
3279 else if ( info.sizer )
3280 return self->IsShown(info.sizer);
3281 else if ( info.gotPos )
3282 return self->IsShown(info.pos);
3283 else
3284 return false;
3285 }
3286
3287 // See pyclasses.h
3288 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3289 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3290 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3291
3292
3293
3294
3295 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3296 {
3297 if (source == Py_None) {
3298 **obj = wxGBPosition(-1,-1);
3299 return true;
3300 }
3301 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3302 }
3303
3304 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3305 {
3306 if (source == Py_None) {
3307 **obj = wxGBSpan(-1,-1);
3308 return true;
3309 }
3310 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3311 }
3312
3313
3314 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3315 self->SetRow(row);
3316 self->SetCol(col);
3317 }
3318 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3319 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3320 PyObject* tup = PyTuple_New(2);
3321 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3322 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3323 wxPyEndBlockThreads(blocked);
3324 return tup;
3325 }
3326 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3327 self->SetRowspan(rowspan);
3328 self->SetColspan(colspan);
3329 }
3330 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3331 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3332 PyObject* tup = PyTuple_New(2);
3333 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3334 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3335 wxPyEndBlockThreads(blocked);
3336 return tup;
3337 }
3338 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3339 wxPyUserData* data = NULL;
3340 if ( userData ) {
3341 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3342 data = new wxPyUserData(userData);
3343 wxPyEndBlockThreads(blocked);
3344 }
3345 return new wxGBSizerItem(window, pos, span, flag, border, data);
3346 }
3347 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,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(sizer, pos, span, flag, border, data);
3355 }
3356 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,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(width, height, pos, span, flag, border, data);
3364 }
3365 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3366 int row, col;
3367 self->GetEndPos(row, col);
3368 return wxGBPosition(row, col);
3369 }
3370 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3371
3372 wxPyUserData* data = NULL;
3373 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3374 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3375 if ( userData && (info.window || info.sizer || info.gotSize) )
3376 data = new wxPyUserData(userData);
3377 wxPyEndBlockThreads(blocked);
3378
3379 // Now call the real Add method if a valid item type was found
3380 if ( info.window )
3381 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3382 else if ( info.sizer )
3383 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3384 else if (info.gotSize)
3385 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3386 pos, span, flag, border, data);
3387 return NULL;
3388 }
3389
3390
3391 #ifdef __cplusplus
3392 extern "C" {
3393 #endif
3394 static int _wrap_EmptyString_set(PyObject *) {
3395 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3396 return 1;
3397 }
3398
3399
3400 static PyObject *_wrap_EmptyString_get(void) {
3401 PyObject *pyobj = NULL;
3402
3403 {
3404 #if wxUSE_UNICODE
3405 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3406 #else
3407 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3408 #endif
3409 }
3410 return pyobj;
3411 }
3412
3413
3414 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3415 PyObject *resultobj = NULL;
3416 wxObject *arg1 = (wxObject *) 0 ;
3417 wxString result;
3418 PyObject * obj0 = 0 ;
3419 char *kwnames[] = {
3420 (char *) "self", NULL
3421 };
3422
3423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3425 if (SWIG_arg_fail(1)) SWIG_fail;
3426 {
3427 PyThreadState* __tstate = wxPyBeginAllowThreads();
3428 result = wxObject_GetClassName(arg1);
3429
3430 wxPyEndAllowThreads(__tstate);
3431 if (PyErr_Occurred()) SWIG_fail;
3432 }
3433 {
3434 #if wxUSE_UNICODE
3435 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3436 #else
3437 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3438 #endif
3439 }
3440 return resultobj;
3441 fail:
3442 return NULL;
3443 }
3444
3445
3446 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3447 PyObject *resultobj = NULL;
3448 wxObject *arg1 = (wxObject *) 0 ;
3449 PyObject * obj0 = 0 ;
3450 char *kwnames[] = {
3451 (char *) "self", NULL
3452 };
3453
3454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3456 if (SWIG_arg_fail(1)) SWIG_fail;
3457 {
3458 PyThreadState* __tstate = wxPyBeginAllowThreads();
3459 wxObject_Destroy(arg1);
3460
3461 wxPyEndAllowThreads(__tstate);
3462 if (PyErr_Occurred()) SWIG_fail;
3463 }
3464 Py_INCREF(Py_None); resultobj = Py_None;
3465 return resultobj;
3466 fail:
3467 return NULL;
3468 }
3469
3470
3471 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3472 PyObject *obj;
3473 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3474 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3475 Py_INCREF(obj);
3476 return Py_BuildValue((char *)"");
3477 }
3478 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3479 PyObject *resultobj = NULL;
3480 wxSize *arg1 = (wxSize *) 0 ;
3481 int arg2 ;
3482 PyObject * obj0 = 0 ;
3483 PyObject * obj1 = 0 ;
3484 char *kwnames[] = {
3485 (char *) "self",(char *) "x", NULL
3486 };
3487
3488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3490 if (SWIG_arg_fail(1)) SWIG_fail;
3491 {
3492 arg2 = static_cast<int >(SWIG_As_int(obj1));
3493 if (SWIG_arg_fail(2)) SWIG_fail;
3494 }
3495 if (arg1) (arg1)->x = arg2;
3496
3497 Py_INCREF(Py_None); resultobj = Py_None;
3498 return resultobj;
3499 fail:
3500 return NULL;
3501 }
3502
3503
3504 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3505 PyObject *resultobj = NULL;
3506 wxSize *arg1 = (wxSize *) 0 ;
3507 int result;
3508 PyObject * obj0 = 0 ;
3509 char *kwnames[] = {
3510 (char *) "self", NULL
3511 };
3512
3513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3515 if (SWIG_arg_fail(1)) SWIG_fail;
3516 result = (int) ((arg1)->x);
3517
3518 {
3519 resultobj = SWIG_From_int(static_cast<int >(result));
3520 }
3521 return resultobj;
3522 fail:
3523 return NULL;
3524 }
3525
3526
3527 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3528 PyObject *resultobj = NULL;
3529 wxSize *arg1 = (wxSize *) 0 ;
3530 int arg2 ;
3531 PyObject * obj0 = 0 ;
3532 PyObject * obj1 = 0 ;
3533 char *kwnames[] = {
3534 (char *) "self",(char *) "y", NULL
3535 };
3536
3537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3539 if (SWIG_arg_fail(1)) SWIG_fail;
3540 {
3541 arg2 = static_cast<int >(SWIG_As_int(obj1));
3542 if (SWIG_arg_fail(2)) SWIG_fail;
3543 }
3544 if (arg1) (arg1)->y = arg2;
3545
3546 Py_INCREF(Py_None); resultobj = Py_None;
3547 return resultobj;
3548 fail:
3549 return NULL;
3550 }
3551
3552
3553 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3554 PyObject *resultobj = NULL;
3555 wxSize *arg1 = (wxSize *) 0 ;
3556 int result;
3557 PyObject * obj0 = 0 ;
3558 char *kwnames[] = {
3559 (char *) "self", NULL
3560 };
3561
3562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3564 if (SWIG_arg_fail(1)) SWIG_fail;
3565 result = (int) ((arg1)->y);
3566
3567 {
3568 resultobj = SWIG_From_int(static_cast<int >(result));
3569 }
3570 return resultobj;
3571 fail:
3572 return NULL;
3573 }
3574
3575
3576 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3577 PyObject *resultobj = NULL;
3578 int arg1 = (int) 0 ;
3579 int arg2 = (int) 0 ;
3580 wxSize *result;
3581 PyObject * obj0 = 0 ;
3582 PyObject * obj1 = 0 ;
3583 char *kwnames[] = {
3584 (char *) "w",(char *) "h", NULL
3585 };
3586
3587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3588 if (obj0) {
3589 {
3590 arg1 = static_cast<int >(SWIG_As_int(obj0));
3591 if (SWIG_arg_fail(1)) SWIG_fail;
3592 }
3593 }
3594 if (obj1) {
3595 {
3596 arg2 = static_cast<int >(SWIG_As_int(obj1));
3597 if (SWIG_arg_fail(2)) SWIG_fail;
3598 }
3599 }
3600 {
3601 PyThreadState* __tstate = wxPyBeginAllowThreads();
3602 result = (wxSize *)new wxSize(arg1,arg2);
3603
3604 wxPyEndAllowThreads(__tstate);
3605 if (PyErr_Occurred()) SWIG_fail;
3606 }
3607 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3608 return resultobj;
3609 fail:
3610 return NULL;
3611 }
3612
3613
3614 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3615 PyObject *resultobj = NULL;
3616 wxSize *arg1 = (wxSize *) 0 ;
3617 PyObject * obj0 = 0 ;
3618 char *kwnames[] = {
3619 (char *) "self", NULL
3620 };
3621
3622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3624 if (SWIG_arg_fail(1)) SWIG_fail;
3625 {
3626 PyThreadState* __tstate = wxPyBeginAllowThreads();
3627 delete arg1;
3628
3629 wxPyEndAllowThreads(__tstate);
3630 if (PyErr_Occurred()) SWIG_fail;
3631 }
3632 Py_INCREF(Py_None); resultobj = Py_None;
3633 return resultobj;
3634 fail:
3635 return NULL;
3636 }
3637
3638
3639 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3640 PyObject *resultobj = NULL;
3641 wxSize *arg1 = (wxSize *) 0 ;
3642 wxSize *arg2 = 0 ;
3643 bool result;
3644 wxSize temp2 ;
3645 PyObject * obj0 = 0 ;
3646 PyObject * obj1 = 0 ;
3647 char *kwnames[] = {
3648 (char *) "self",(char *) "sz", NULL
3649 };
3650
3651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3653 if (SWIG_arg_fail(1)) SWIG_fail;
3654 {
3655 arg2 = &temp2;
3656 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3657 }
3658 {
3659 PyThreadState* __tstate = wxPyBeginAllowThreads();
3660 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3661
3662 wxPyEndAllowThreads(__tstate);
3663 if (PyErr_Occurred()) SWIG_fail;
3664 }
3665 {
3666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3667 }
3668 return resultobj;
3669 fail:
3670 return NULL;
3671 }
3672
3673
3674 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3675 PyObject *resultobj = NULL;
3676 wxSize *arg1 = (wxSize *) 0 ;
3677 wxSize *arg2 = 0 ;
3678 bool result;
3679 wxSize temp2 ;
3680 PyObject * obj0 = 0 ;
3681 PyObject * obj1 = 0 ;
3682 char *kwnames[] = {
3683 (char *) "self",(char *) "sz", NULL
3684 };
3685
3686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3688 if (SWIG_arg_fail(1)) SWIG_fail;
3689 {
3690 arg2 = &temp2;
3691 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3692 }
3693 {
3694 PyThreadState* __tstate = wxPyBeginAllowThreads();
3695 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3696
3697 wxPyEndAllowThreads(__tstate);
3698 if (PyErr_Occurred()) SWIG_fail;
3699 }
3700 {
3701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3702 }
3703 return resultobj;
3704 fail:
3705 return NULL;
3706 }
3707
3708
3709 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3710 PyObject *resultobj = NULL;
3711 wxSize *arg1 = (wxSize *) 0 ;
3712 wxSize *arg2 = 0 ;
3713 wxSize result;
3714 wxSize temp2 ;
3715 PyObject * obj0 = 0 ;
3716 PyObject * obj1 = 0 ;
3717 char *kwnames[] = {
3718 (char *) "self",(char *) "sz", NULL
3719 };
3720
3721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3723 if (SWIG_arg_fail(1)) SWIG_fail;
3724 {
3725 arg2 = &temp2;
3726 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3727 }
3728 {
3729 PyThreadState* __tstate = wxPyBeginAllowThreads();
3730 result = (arg1)->operator +((wxSize const &)*arg2);
3731
3732 wxPyEndAllowThreads(__tstate);
3733 if (PyErr_Occurred()) SWIG_fail;
3734 }
3735 {
3736 wxSize * resultptr;
3737 resultptr = new wxSize(static_cast<wxSize & >(result));
3738 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3739 }
3740 return resultobj;
3741 fail:
3742 return NULL;
3743 }
3744
3745
3746 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3747 PyObject *resultobj = NULL;
3748 wxSize *arg1 = (wxSize *) 0 ;
3749 wxSize *arg2 = 0 ;
3750 wxSize result;
3751 wxSize temp2 ;
3752 PyObject * obj0 = 0 ;
3753 PyObject * obj1 = 0 ;
3754 char *kwnames[] = {
3755 (char *) "self",(char *) "sz", NULL
3756 };
3757
3758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3760 if (SWIG_arg_fail(1)) SWIG_fail;
3761 {
3762 arg2 = &temp2;
3763 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3764 }
3765 {
3766 PyThreadState* __tstate = wxPyBeginAllowThreads();
3767 result = (arg1)->operator -((wxSize const &)*arg2);
3768
3769 wxPyEndAllowThreads(__tstate);
3770 if (PyErr_Occurred()) SWIG_fail;
3771 }
3772 {
3773 wxSize * resultptr;
3774 resultptr = new wxSize(static_cast<wxSize & >(result));
3775 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3776 }
3777 return resultobj;
3778 fail:
3779 return NULL;
3780 }
3781
3782
3783 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3784 PyObject *resultobj = NULL;
3785 wxSize *arg1 = (wxSize *) 0 ;
3786 wxSize *arg2 = 0 ;
3787 wxSize temp2 ;
3788 PyObject * obj0 = 0 ;
3789 PyObject * obj1 = 0 ;
3790 char *kwnames[] = {
3791 (char *) "self",(char *) "sz", NULL
3792 };
3793
3794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3796 if (SWIG_arg_fail(1)) SWIG_fail;
3797 {
3798 arg2 = &temp2;
3799 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3800 }
3801 {
3802 PyThreadState* __tstate = wxPyBeginAllowThreads();
3803 (arg1)->IncTo((wxSize const &)*arg2);
3804
3805 wxPyEndAllowThreads(__tstate);
3806 if (PyErr_Occurred()) SWIG_fail;
3807 }
3808 Py_INCREF(Py_None); resultobj = Py_None;
3809 return resultobj;
3810 fail:
3811 return NULL;
3812 }
3813
3814
3815 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3816 PyObject *resultobj = NULL;
3817 wxSize *arg1 = (wxSize *) 0 ;
3818 wxSize *arg2 = 0 ;
3819 wxSize temp2 ;
3820 PyObject * obj0 = 0 ;
3821 PyObject * obj1 = 0 ;
3822 char *kwnames[] = {
3823 (char *) "self",(char *) "sz", NULL
3824 };
3825
3826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3828 if (SWIG_arg_fail(1)) SWIG_fail;
3829 {
3830 arg2 = &temp2;
3831 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3832 }
3833 {
3834 PyThreadState* __tstate = wxPyBeginAllowThreads();
3835 (arg1)->DecTo((wxSize const &)*arg2);
3836
3837 wxPyEndAllowThreads(__tstate);
3838 if (PyErr_Occurred()) SWIG_fail;
3839 }
3840 Py_INCREF(Py_None); resultobj = Py_None;
3841 return resultobj;
3842 fail:
3843 return NULL;
3844 }
3845
3846
3847 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3848 PyObject *resultobj = NULL;
3849 wxSize *arg1 = (wxSize *) 0 ;
3850 int arg2 ;
3851 int arg3 ;
3852 PyObject * obj0 = 0 ;
3853 PyObject * obj1 = 0 ;
3854 PyObject * obj2 = 0 ;
3855 char *kwnames[] = {
3856 (char *) "self",(char *) "w",(char *) "h", NULL
3857 };
3858
3859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3861 if (SWIG_arg_fail(1)) SWIG_fail;
3862 {
3863 arg2 = static_cast<int >(SWIG_As_int(obj1));
3864 if (SWIG_arg_fail(2)) SWIG_fail;
3865 }
3866 {
3867 arg3 = static_cast<int >(SWIG_As_int(obj2));
3868 if (SWIG_arg_fail(3)) SWIG_fail;
3869 }
3870 {
3871 PyThreadState* __tstate = wxPyBeginAllowThreads();
3872 (arg1)->Set(arg2,arg3);
3873
3874 wxPyEndAllowThreads(__tstate);
3875 if (PyErr_Occurred()) SWIG_fail;
3876 }
3877 Py_INCREF(Py_None); resultobj = Py_None;
3878 return resultobj;
3879 fail:
3880 return NULL;
3881 }
3882
3883
3884 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3885 PyObject *resultobj = NULL;
3886 wxSize *arg1 = (wxSize *) 0 ;
3887 int arg2 ;
3888 PyObject * obj0 = 0 ;
3889 PyObject * obj1 = 0 ;
3890 char *kwnames[] = {
3891 (char *) "self",(char *) "w", NULL
3892 };
3893
3894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3896 if (SWIG_arg_fail(1)) SWIG_fail;
3897 {
3898 arg2 = static_cast<int >(SWIG_As_int(obj1));
3899 if (SWIG_arg_fail(2)) SWIG_fail;
3900 }
3901 {
3902 PyThreadState* __tstate = wxPyBeginAllowThreads();
3903 (arg1)->SetWidth(arg2);
3904
3905 wxPyEndAllowThreads(__tstate);
3906 if (PyErr_Occurred()) SWIG_fail;
3907 }
3908 Py_INCREF(Py_None); resultobj = Py_None;
3909 return resultobj;
3910 fail:
3911 return NULL;
3912 }
3913
3914
3915 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3916 PyObject *resultobj = NULL;
3917 wxSize *arg1 = (wxSize *) 0 ;
3918 int arg2 ;
3919 PyObject * obj0 = 0 ;
3920 PyObject * obj1 = 0 ;
3921 char *kwnames[] = {
3922 (char *) "self",(char *) "h", NULL
3923 };
3924
3925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3927 if (SWIG_arg_fail(1)) SWIG_fail;
3928 {
3929 arg2 = static_cast<int >(SWIG_As_int(obj1));
3930 if (SWIG_arg_fail(2)) SWIG_fail;
3931 }
3932 {
3933 PyThreadState* __tstate = wxPyBeginAllowThreads();
3934 (arg1)->SetHeight(arg2);
3935
3936 wxPyEndAllowThreads(__tstate);
3937 if (PyErr_Occurred()) SWIG_fail;
3938 }
3939 Py_INCREF(Py_None); resultobj = Py_None;
3940 return resultobj;
3941 fail:
3942 return NULL;
3943 }
3944
3945
3946 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3947 PyObject *resultobj = NULL;
3948 wxSize *arg1 = (wxSize *) 0 ;
3949 int result;
3950 PyObject * obj0 = 0 ;
3951 char *kwnames[] = {
3952 (char *) "self", NULL
3953 };
3954
3955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3957 if (SWIG_arg_fail(1)) SWIG_fail;
3958 {
3959 PyThreadState* __tstate = wxPyBeginAllowThreads();
3960 result = (int)((wxSize const *)arg1)->GetWidth();
3961
3962 wxPyEndAllowThreads(__tstate);
3963 if (PyErr_Occurred()) SWIG_fail;
3964 }
3965 {
3966 resultobj = SWIG_From_int(static_cast<int >(result));
3967 }
3968 return resultobj;
3969 fail:
3970 return NULL;
3971 }
3972
3973
3974 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3975 PyObject *resultobj = NULL;
3976 wxSize *arg1 = (wxSize *) 0 ;
3977 int result;
3978 PyObject * obj0 = 0 ;
3979 char *kwnames[] = {
3980 (char *) "self", NULL
3981 };
3982
3983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3985 if (SWIG_arg_fail(1)) SWIG_fail;
3986 {
3987 PyThreadState* __tstate = wxPyBeginAllowThreads();
3988 result = (int)((wxSize const *)arg1)->GetHeight();
3989
3990 wxPyEndAllowThreads(__tstate);
3991 if (PyErr_Occurred()) SWIG_fail;
3992 }
3993 {
3994 resultobj = SWIG_From_int(static_cast<int >(result));
3995 }
3996 return resultobj;
3997 fail:
3998 return NULL;
3999 }
4000
4001
4002 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
4003 PyObject *resultobj = NULL;
4004 wxSize *arg1 = (wxSize *) 0 ;
4005 bool result;
4006 PyObject * obj0 = 0 ;
4007 char *kwnames[] = {
4008 (char *) "self", NULL
4009 };
4010
4011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
4012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4013 if (SWIG_arg_fail(1)) SWIG_fail;
4014 {
4015 PyThreadState* __tstate = wxPyBeginAllowThreads();
4016 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
4017
4018 wxPyEndAllowThreads(__tstate);
4019 if (PyErr_Occurred()) SWIG_fail;
4020 }
4021 {
4022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4023 }
4024 return resultobj;
4025 fail:
4026 return NULL;
4027 }
4028
4029
4030 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
4031 PyObject *resultobj = NULL;
4032 wxSize *arg1 = (wxSize *) 0 ;
4033 wxSize *arg2 = 0 ;
4034 wxSize temp2 ;
4035 PyObject * obj0 = 0 ;
4036 PyObject * obj1 = 0 ;
4037 char *kwnames[] = {
4038 (char *) "self",(char *) "size", NULL
4039 };
4040
4041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
4042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4043 if (SWIG_arg_fail(1)) SWIG_fail;
4044 {
4045 arg2 = &temp2;
4046 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4047 }
4048 {
4049 PyThreadState* __tstate = wxPyBeginAllowThreads();
4050 (arg1)->SetDefaults((wxSize const &)*arg2);
4051
4052 wxPyEndAllowThreads(__tstate);
4053 if (PyErr_Occurred()) SWIG_fail;
4054 }
4055 Py_INCREF(Py_None); resultobj = Py_None;
4056 return resultobj;
4057 fail:
4058 return NULL;
4059 }
4060
4061
4062 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4063 PyObject *resultobj = NULL;
4064 wxSize *arg1 = (wxSize *) 0 ;
4065 PyObject *result;
4066 PyObject * obj0 = 0 ;
4067 char *kwnames[] = {
4068 (char *) "self", NULL
4069 };
4070
4071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
4072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4073 if (SWIG_arg_fail(1)) SWIG_fail;
4074 {
4075 PyThreadState* __tstate = wxPyBeginAllowThreads();
4076 result = (PyObject *)wxSize_Get(arg1);
4077
4078 wxPyEndAllowThreads(__tstate);
4079 if (PyErr_Occurred()) SWIG_fail;
4080 }
4081 resultobj = result;
4082 return resultobj;
4083 fail:
4084 return NULL;
4085 }
4086
4087
4088 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
4089 PyObject *obj;
4090 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4091 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
4092 Py_INCREF(obj);
4093 return Py_BuildValue((char *)"");
4094 }
4095 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4096 PyObject *resultobj = NULL;
4097 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4098 double arg2 ;
4099 PyObject * obj0 = 0 ;
4100 PyObject * obj1 = 0 ;
4101 char *kwnames[] = {
4102 (char *) "self",(char *) "x", NULL
4103 };
4104
4105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
4106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4107 if (SWIG_arg_fail(1)) SWIG_fail;
4108 {
4109 arg2 = static_cast<double >(SWIG_As_double(obj1));
4110 if (SWIG_arg_fail(2)) SWIG_fail;
4111 }
4112 if (arg1) (arg1)->x = arg2;
4113
4114 Py_INCREF(Py_None); resultobj = Py_None;
4115 return resultobj;
4116 fail:
4117 return NULL;
4118 }
4119
4120
4121 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4122 PyObject *resultobj = NULL;
4123 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4124 double result;
4125 PyObject * obj0 = 0 ;
4126 char *kwnames[] = {
4127 (char *) "self", NULL
4128 };
4129
4130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
4131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4132 if (SWIG_arg_fail(1)) SWIG_fail;
4133 result = (double) ((arg1)->x);
4134
4135 {
4136 resultobj = SWIG_From_double(static_cast<double >(result));
4137 }
4138 return resultobj;
4139 fail:
4140 return NULL;
4141 }
4142
4143
4144 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4145 PyObject *resultobj = NULL;
4146 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4147 double arg2 ;
4148 PyObject * obj0 = 0 ;
4149 PyObject * obj1 = 0 ;
4150 char *kwnames[] = {
4151 (char *) "self",(char *) "y", NULL
4152 };
4153
4154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4156 if (SWIG_arg_fail(1)) SWIG_fail;
4157 {
4158 arg2 = static_cast<double >(SWIG_As_double(obj1));
4159 if (SWIG_arg_fail(2)) SWIG_fail;
4160 }
4161 if (arg1) (arg1)->y = arg2;
4162
4163 Py_INCREF(Py_None); resultobj = Py_None;
4164 return resultobj;
4165 fail:
4166 return NULL;
4167 }
4168
4169
4170 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4171 PyObject *resultobj = NULL;
4172 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4173 double result;
4174 PyObject * obj0 = 0 ;
4175 char *kwnames[] = {
4176 (char *) "self", NULL
4177 };
4178
4179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4181 if (SWIG_arg_fail(1)) SWIG_fail;
4182 result = (double) ((arg1)->y);
4183
4184 {
4185 resultobj = SWIG_From_double(static_cast<double >(result));
4186 }
4187 return resultobj;
4188 fail:
4189 return NULL;
4190 }
4191
4192
4193 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4194 PyObject *resultobj = NULL;
4195 double arg1 = (double) 0.0 ;
4196 double arg2 = (double) 0.0 ;
4197 wxRealPoint *result;
4198 PyObject * obj0 = 0 ;
4199 PyObject * obj1 = 0 ;
4200 char *kwnames[] = {
4201 (char *) "x",(char *) "y", NULL
4202 };
4203
4204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4205 if (obj0) {
4206 {
4207 arg1 = static_cast<double >(SWIG_As_double(obj0));
4208 if (SWIG_arg_fail(1)) SWIG_fail;
4209 }
4210 }
4211 if (obj1) {
4212 {
4213 arg2 = static_cast<double >(SWIG_As_double(obj1));
4214 if (SWIG_arg_fail(2)) SWIG_fail;
4215 }
4216 }
4217 {
4218 PyThreadState* __tstate = wxPyBeginAllowThreads();
4219 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4220
4221 wxPyEndAllowThreads(__tstate);
4222 if (PyErr_Occurred()) SWIG_fail;
4223 }
4224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4225 return resultobj;
4226 fail:
4227 return NULL;
4228 }
4229
4230
4231 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4232 PyObject *resultobj = NULL;
4233 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4234 PyObject * obj0 = 0 ;
4235 char *kwnames[] = {
4236 (char *) "self", NULL
4237 };
4238
4239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4241 if (SWIG_arg_fail(1)) SWIG_fail;
4242 {
4243 PyThreadState* __tstate = wxPyBeginAllowThreads();
4244 delete arg1;
4245
4246 wxPyEndAllowThreads(__tstate);
4247 if (PyErr_Occurred()) SWIG_fail;
4248 }
4249 Py_INCREF(Py_None); resultobj = Py_None;
4250 return resultobj;
4251 fail:
4252 return NULL;
4253 }
4254
4255
4256 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4257 PyObject *resultobj = NULL;
4258 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4259 wxRealPoint *arg2 = 0 ;
4260 bool result;
4261 wxRealPoint temp2 ;
4262 PyObject * obj0 = 0 ;
4263 PyObject * obj1 = 0 ;
4264 char *kwnames[] = {
4265 (char *) "self",(char *) "pt", NULL
4266 };
4267
4268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4270 if (SWIG_arg_fail(1)) SWIG_fail;
4271 {
4272 arg2 = &temp2;
4273 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4274 }
4275 {
4276 PyThreadState* __tstate = wxPyBeginAllowThreads();
4277 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4278
4279 wxPyEndAllowThreads(__tstate);
4280 if (PyErr_Occurred()) SWIG_fail;
4281 }
4282 {
4283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4284 }
4285 return resultobj;
4286 fail:
4287 return NULL;
4288 }
4289
4290
4291 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4292 PyObject *resultobj = NULL;
4293 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4294 wxRealPoint *arg2 = 0 ;
4295 bool result;
4296 wxRealPoint temp2 ;
4297 PyObject * obj0 = 0 ;
4298 PyObject * obj1 = 0 ;
4299 char *kwnames[] = {
4300 (char *) "self",(char *) "pt", NULL
4301 };
4302
4303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4305 if (SWIG_arg_fail(1)) SWIG_fail;
4306 {
4307 arg2 = &temp2;
4308 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4309 }
4310 {
4311 PyThreadState* __tstate = wxPyBeginAllowThreads();
4312 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4313
4314 wxPyEndAllowThreads(__tstate);
4315 if (PyErr_Occurred()) SWIG_fail;
4316 }
4317 {
4318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4319 }
4320 return resultobj;
4321 fail:
4322 return NULL;
4323 }
4324
4325
4326 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4327 PyObject *resultobj = NULL;
4328 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4329 wxRealPoint *arg2 = 0 ;
4330 wxRealPoint result;
4331 wxRealPoint temp2 ;
4332 PyObject * obj0 = 0 ;
4333 PyObject * obj1 = 0 ;
4334 char *kwnames[] = {
4335 (char *) "self",(char *) "pt", NULL
4336 };
4337
4338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4340 if (SWIG_arg_fail(1)) SWIG_fail;
4341 {
4342 arg2 = &temp2;
4343 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4344 }
4345 {
4346 PyThreadState* __tstate = wxPyBeginAllowThreads();
4347 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4348
4349 wxPyEndAllowThreads(__tstate);
4350 if (PyErr_Occurred()) SWIG_fail;
4351 }
4352 {
4353 wxRealPoint * resultptr;
4354 resultptr = new wxRealPoint(static_cast<wxRealPoint & >(result));
4355 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4356 }
4357 return resultobj;
4358 fail:
4359 return NULL;
4360 }
4361
4362
4363 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4364 PyObject *resultobj = NULL;
4365 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4366 wxRealPoint *arg2 = 0 ;
4367 wxRealPoint result;
4368 wxRealPoint temp2 ;
4369 PyObject * obj0 = 0 ;
4370 PyObject * obj1 = 0 ;
4371 char *kwnames[] = {
4372 (char *) "self",(char *) "pt", NULL
4373 };
4374
4375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4377 if (SWIG_arg_fail(1)) SWIG_fail;
4378 {
4379 arg2 = &temp2;
4380 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4381 }
4382 {
4383 PyThreadState* __tstate = wxPyBeginAllowThreads();
4384 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4385
4386 wxPyEndAllowThreads(__tstate);
4387 if (PyErr_Occurred()) SWIG_fail;
4388 }
4389 {
4390 wxRealPoint * resultptr;
4391 resultptr = new wxRealPoint(static_cast<wxRealPoint & >(result));
4392 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4393 }
4394 return resultobj;
4395 fail:
4396 return NULL;
4397 }
4398
4399
4400 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4401 PyObject *resultobj = NULL;
4402 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4403 double arg2 ;
4404 double arg3 ;
4405 PyObject * obj0 = 0 ;
4406 PyObject * obj1 = 0 ;
4407 PyObject * obj2 = 0 ;
4408 char *kwnames[] = {
4409 (char *) "self",(char *) "x",(char *) "y", NULL
4410 };
4411
4412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4414 if (SWIG_arg_fail(1)) SWIG_fail;
4415 {
4416 arg2 = static_cast<double >(SWIG_As_double(obj1));
4417 if (SWIG_arg_fail(2)) SWIG_fail;
4418 }
4419 {
4420 arg3 = static_cast<double >(SWIG_As_double(obj2));
4421 if (SWIG_arg_fail(3)) SWIG_fail;
4422 }
4423 {
4424 PyThreadState* __tstate = wxPyBeginAllowThreads();
4425 wxRealPoint_Set(arg1,arg2,arg3);
4426
4427 wxPyEndAllowThreads(__tstate);
4428 if (PyErr_Occurred()) SWIG_fail;
4429 }
4430 Py_INCREF(Py_None); resultobj = Py_None;
4431 return resultobj;
4432 fail:
4433 return NULL;
4434 }
4435
4436
4437 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4438 PyObject *resultobj = NULL;
4439 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4440 PyObject *result;
4441 PyObject * obj0 = 0 ;
4442 char *kwnames[] = {
4443 (char *) "self", NULL
4444 };
4445
4446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4448 if (SWIG_arg_fail(1)) SWIG_fail;
4449 {
4450 PyThreadState* __tstate = wxPyBeginAllowThreads();
4451 result = (PyObject *)wxRealPoint_Get(arg1);
4452
4453 wxPyEndAllowThreads(__tstate);
4454 if (PyErr_Occurred()) SWIG_fail;
4455 }
4456 resultobj = result;
4457 return resultobj;
4458 fail:
4459 return NULL;
4460 }
4461
4462
4463 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4464 PyObject *obj;
4465 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4466 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4467 Py_INCREF(obj);
4468 return Py_BuildValue((char *)"");
4469 }
4470 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4471 PyObject *resultobj = NULL;
4472 wxPoint *arg1 = (wxPoint *) 0 ;
4473 int arg2 ;
4474 PyObject * obj0 = 0 ;
4475 PyObject * obj1 = 0 ;
4476 char *kwnames[] = {
4477 (char *) "self",(char *) "x", NULL
4478 };
4479
4480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4482 if (SWIG_arg_fail(1)) SWIG_fail;
4483 {
4484 arg2 = static_cast<int >(SWIG_As_int(obj1));
4485 if (SWIG_arg_fail(2)) SWIG_fail;
4486 }
4487 if (arg1) (arg1)->x = arg2;
4488
4489 Py_INCREF(Py_None); resultobj = Py_None;
4490 return resultobj;
4491 fail:
4492 return NULL;
4493 }
4494
4495
4496 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4497 PyObject *resultobj = NULL;
4498 wxPoint *arg1 = (wxPoint *) 0 ;
4499 int result;
4500 PyObject * obj0 = 0 ;
4501 char *kwnames[] = {
4502 (char *) "self", NULL
4503 };
4504
4505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4507 if (SWIG_arg_fail(1)) SWIG_fail;
4508 result = (int) ((arg1)->x);
4509
4510 {
4511 resultobj = SWIG_From_int(static_cast<int >(result));
4512 }
4513 return resultobj;
4514 fail:
4515 return NULL;
4516 }
4517
4518
4519 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4520 PyObject *resultobj = NULL;
4521 wxPoint *arg1 = (wxPoint *) 0 ;
4522 int arg2 ;
4523 PyObject * obj0 = 0 ;
4524 PyObject * obj1 = 0 ;
4525 char *kwnames[] = {
4526 (char *) "self",(char *) "y", NULL
4527 };
4528
4529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4531 if (SWIG_arg_fail(1)) SWIG_fail;
4532 {
4533 arg2 = static_cast<int >(SWIG_As_int(obj1));
4534 if (SWIG_arg_fail(2)) SWIG_fail;
4535 }
4536 if (arg1) (arg1)->y = arg2;
4537
4538 Py_INCREF(Py_None); resultobj = Py_None;
4539 return resultobj;
4540 fail:
4541 return NULL;
4542 }
4543
4544
4545 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4546 PyObject *resultobj = NULL;
4547 wxPoint *arg1 = (wxPoint *) 0 ;
4548 int result;
4549 PyObject * obj0 = 0 ;
4550 char *kwnames[] = {
4551 (char *) "self", NULL
4552 };
4553
4554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4556 if (SWIG_arg_fail(1)) SWIG_fail;
4557 result = (int) ((arg1)->y);
4558
4559 {
4560 resultobj = SWIG_From_int(static_cast<int >(result));
4561 }
4562 return resultobj;
4563 fail:
4564 return NULL;
4565 }
4566
4567
4568 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4569 PyObject *resultobj = NULL;
4570 int arg1 = (int) 0 ;
4571 int arg2 = (int) 0 ;
4572 wxPoint *result;
4573 PyObject * obj0 = 0 ;
4574 PyObject * obj1 = 0 ;
4575 char *kwnames[] = {
4576 (char *) "x",(char *) "y", NULL
4577 };
4578
4579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4580 if (obj0) {
4581 {
4582 arg1 = static_cast<int >(SWIG_As_int(obj0));
4583 if (SWIG_arg_fail(1)) SWIG_fail;
4584 }
4585 }
4586 if (obj1) {
4587 {
4588 arg2 = static_cast<int >(SWIG_As_int(obj1));
4589 if (SWIG_arg_fail(2)) SWIG_fail;
4590 }
4591 }
4592 {
4593 PyThreadState* __tstate = wxPyBeginAllowThreads();
4594 result = (wxPoint *)new wxPoint(arg1,arg2);
4595
4596 wxPyEndAllowThreads(__tstate);
4597 if (PyErr_Occurred()) SWIG_fail;
4598 }
4599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4600 return resultobj;
4601 fail:
4602 return NULL;
4603 }
4604
4605
4606 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4607 PyObject *resultobj = NULL;
4608 wxPoint *arg1 = (wxPoint *) 0 ;
4609 PyObject * obj0 = 0 ;
4610 char *kwnames[] = {
4611 (char *) "self", NULL
4612 };
4613
4614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4616 if (SWIG_arg_fail(1)) SWIG_fail;
4617 {
4618 PyThreadState* __tstate = wxPyBeginAllowThreads();
4619 delete arg1;
4620
4621 wxPyEndAllowThreads(__tstate);
4622 if (PyErr_Occurred()) SWIG_fail;
4623 }
4624 Py_INCREF(Py_None); resultobj = Py_None;
4625 return resultobj;
4626 fail:
4627 return NULL;
4628 }
4629
4630
4631 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4632 PyObject *resultobj = NULL;
4633 wxPoint *arg1 = (wxPoint *) 0 ;
4634 wxPoint *arg2 = 0 ;
4635 bool result;
4636 wxPoint temp2 ;
4637 PyObject * obj0 = 0 ;
4638 PyObject * obj1 = 0 ;
4639 char *kwnames[] = {
4640 (char *) "self",(char *) "pt", NULL
4641 };
4642
4643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4645 if (SWIG_arg_fail(1)) SWIG_fail;
4646 {
4647 arg2 = &temp2;
4648 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4649 }
4650 {
4651 PyThreadState* __tstate = wxPyBeginAllowThreads();
4652 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4653
4654 wxPyEndAllowThreads(__tstate);
4655 if (PyErr_Occurred()) SWIG_fail;
4656 }
4657 {
4658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4659 }
4660 return resultobj;
4661 fail:
4662 return NULL;
4663 }
4664
4665
4666 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4667 PyObject *resultobj = NULL;
4668 wxPoint *arg1 = (wxPoint *) 0 ;
4669 wxPoint *arg2 = 0 ;
4670 bool result;
4671 wxPoint temp2 ;
4672 PyObject * obj0 = 0 ;
4673 PyObject * obj1 = 0 ;
4674 char *kwnames[] = {
4675 (char *) "self",(char *) "pt", NULL
4676 };
4677
4678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4680 if (SWIG_arg_fail(1)) SWIG_fail;
4681 {
4682 arg2 = &temp2;
4683 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4684 }
4685 {
4686 PyThreadState* __tstate = wxPyBeginAllowThreads();
4687 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4688
4689 wxPyEndAllowThreads(__tstate);
4690 if (PyErr_Occurred()) SWIG_fail;
4691 }
4692 {
4693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4694 }
4695 return resultobj;
4696 fail:
4697 return NULL;
4698 }
4699
4700
4701 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4702 PyObject *resultobj = NULL;
4703 wxPoint *arg1 = (wxPoint *) 0 ;
4704 wxPoint *arg2 = 0 ;
4705 wxPoint result;
4706 wxPoint temp2 ;
4707 PyObject * obj0 = 0 ;
4708 PyObject * obj1 = 0 ;
4709 char *kwnames[] = {
4710 (char *) "self",(char *) "pt", NULL
4711 };
4712
4713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4715 if (SWIG_arg_fail(1)) SWIG_fail;
4716 {
4717 arg2 = &temp2;
4718 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4719 }
4720 {
4721 PyThreadState* __tstate = wxPyBeginAllowThreads();
4722 result = (arg1)->operator +((wxPoint const &)*arg2);
4723
4724 wxPyEndAllowThreads(__tstate);
4725 if (PyErr_Occurred()) SWIG_fail;
4726 }
4727 {
4728 wxPoint * resultptr;
4729 resultptr = new wxPoint(static_cast<wxPoint & >(result));
4730 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4731 }
4732 return resultobj;
4733 fail:
4734 return NULL;
4735 }
4736
4737
4738 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4739 PyObject *resultobj = NULL;
4740 wxPoint *arg1 = (wxPoint *) 0 ;
4741 wxPoint *arg2 = 0 ;
4742 wxPoint result;
4743 wxPoint temp2 ;
4744 PyObject * obj0 = 0 ;
4745 PyObject * obj1 = 0 ;
4746 char *kwnames[] = {
4747 (char *) "self",(char *) "pt", NULL
4748 };
4749
4750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4752 if (SWIG_arg_fail(1)) SWIG_fail;
4753 {
4754 arg2 = &temp2;
4755 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4756 }
4757 {
4758 PyThreadState* __tstate = wxPyBeginAllowThreads();
4759 result = (arg1)->operator -((wxPoint const &)*arg2);
4760
4761 wxPyEndAllowThreads(__tstate);
4762 if (PyErr_Occurred()) SWIG_fail;
4763 }
4764 {
4765 wxPoint * resultptr;
4766 resultptr = new wxPoint(static_cast<wxPoint & >(result));
4767 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4768 }
4769 return resultobj;
4770 fail:
4771 return NULL;
4772 }
4773
4774
4775 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4776 PyObject *resultobj = NULL;
4777 wxPoint *arg1 = (wxPoint *) 0 ;
4778 wxPoint *arg2 = 0 ;
4779 wxPoint *result;
4780 wxPoint temp2 ;
4781 PyObject * obj0 = 0 ;
4782 PyObject * obj1 = 0 ;
4783 char *kwnames[] = {
4784 (char *) "self",(char *) "pt", NULL
4785 };
4786
4787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4789 if (SWIG_arg_fail(1)) SWIG_fail;
4790 {
4791 arg2 = &temp2;
4792 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4793 }
4794 {
4795 PyThreadState* __tstate = wxPyBeginAllowThreads();
4796 {
4797 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4798 result = (wxPoint *) &_result_ref;
4799 }
4800
4801 wxPyEndAllowThreads(__tstate);
4802 if (PyErr_Occurred()) SWIG_fail;
4803 }
4804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4805 return resultobj;
4806 fail:
4807 return NULL;
4808 }
4809
4810
4811 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4812 PyObject *resultobj = NULL;
4813 wxPoint *arg1 = (wxPoint *) 0 ;
4814 wxPoint *arg2 = 0 ;
4815 wxPoint *result;
4816 wxPoint temp2 ;
4817 PyObject * obj0 = 0 ;
4818 PyObject * obj1 = 0 ;
4819 char *kwnames[] = {
4820 (char *) "self",(char *) "pt", NULL
4821 };
4822
4823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4825 if (SWIG_arg_fail(1)) SWIG_fail;
4826 {
4827 arg2 = &temp2;
4828 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4829 }
4830 {
4831 PyThreadState* __tstate = wxPyBeginAllowThreads();
4832 {
4833 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4834 result = (wxPoint *) &_result_ref;
4835 }
4836
4837 wxPyEndAllowThreads(__tstate);
4838 if (PyErr_Occurred()) SWIG_fail;
4839 }
4840 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4841 return resultobj;
4842 fail:
4843 return NULL;
4844 }
4845
4846
4847 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4848 PyObject *resultobj = NULL;
4849 wxPoint *arg1 = (wxPoint *) 0 ;
4850 long arg2 ;
4851 long arg3 ;
4852 PyObject * obj0 = 0 ;
4853 PyObject * obj1 = 0 ;
4854 PyObject * obj2 = 0 ;
4855 char *kwnames[] = {
4856 (char *) "self",(char *) "x",(char *) "y", NULL
4857 };
4858
4859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4861 if (SWIG_arg_fail(1)) SWIG_fail;
4862 {
4863 arg2 = static_cast<long >(SWIG_As_long(obj1));
4864 if (SWIG_arg_fail(2)) SWIG_fail;
4865 }
4866 {
4867 arg3 = static_cast<long >(SWIG_As_long(obj2));
4868 if (SWIG_arg_fail(3)) SWIG_fail;
4869 }
4870 {
4871 PyThreadState* __tstate = wxPyBeginAllowThreads();
4872 wxPoint_Set(arg1,arg2,arg3);
4873
4874 wxPyEndAllowThreads(__tstate);
4875 if (PyErr_Occurred()) SWIG_fail;
4876 }
4877 Py_INCREF(Py_None); resultobj = Py_None;
4878 return resultobj;
4879 fail:
4880 return NULL;
4881 }
4882
4883
4884 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4885 PyObject *resultobj = NULL;
4886 wxPoint *arg1 = (wxPoint *) 0 ;
4887 PyObject *result;
4888 PyObject * obj0 = 0 ;
4889 char *kwnames[] = {
4890 (char *) "self", NULL
4891 };
4892
4893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4895 if (SWIG_arg_fail(1)) SWIG_fail;
4896 {
4897 PyThreadState* __tstate = wxPyBeginAllowThreads();
4898 result = (PyObject *)wxPoint_Get(arg1);
4899
4900 wxPyEndAllowThreads(__tstate);
4901 if (PyErr_Occurred()) SWIG_fail;
4902 }
4903 resultobj = result;
4904 return resultobj;
4905 fail:
4906 return NULL;
4907 }
4908
4909
4910 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4911 PyObject *obj;
4912 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4913 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4914 Py_INCREF(obj);
4915 return Py_BuildValue((char *)"");
4916 }
4917 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4918 PyObject *resultobj = NULL;
4919 int arg1 = (int) 0 ;
4920 int arg2 = (int) 0 ;
4921 int arg3 = (int) 0 ;
4922 int arg4 = (int) 0 ;
4923 wxRect *result;
4924 PyObject * obj0 = 0 ;
4925 PyObject * obj1 = 0 ;
4926 PyObject * obj2 = 0 ;
4927 PyObject * obj3 = 0 ;
4928 char *kwnames[] = {
4929 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4930 };
4931
4932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4933 if (obj0) {
4934 {
4935 arg1 = static_cast<int >(SWIG_As_int(obj0));
4936 if (SWIG_arg_fail(1)) SWIG_fail;
4937 }
4938 }
4939 if (obj1) {
4940 {
4941 arg2 = static_cast<int >(SWIG_As_int(obj1));
4942 if (SWIG_arg_fail(2)) SWIG_fail;
4943 }
4944 }
4945 if (obj2) {
4946 {
4947 arg3 = static_cast<int >(SWIG_As_int(obj2));
4948 if (SWIG_arg_fail(3)) SWIG_fail;
4949 }
4950 }
4951 if (obj3) {
4952 {
4953 arg4 = static_cast<int >(SWIG_As_int(obj3));
4954 if (SWIG_arg_fail(4)) SWIG_fail;
4955 }
4956 }
4957 {
4958 PyThreadState* __tstate = wxPyBeginAllowThreads();
4959 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4960
4961 wxPyEndAllowThreads(__tstate);
4962 if (PyErr_Occurred()) SWIG_fail;
4963 }
4964 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4965 return resultobj;
4966 fail:
4967 return NULL;
4968 }
4969
4970
4971 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4972 PyObject *resultobj = NULL;
4973 wxPoint *arg1 = 0 ;
4974 wxPoint *arg2 = 0 ;
4975 wxRect *result;
4976 wxPoint temp1 ;
4977 wxPoint temp2 ;
4978 PyObject * obj0 = 0 ;
4979 PyObject * obj1 = 0 ;
4980 char *kwnames[] = {
4981 (char *) "topLeft",(char *) "bottomRight", NULL
4982 };
4983
4984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4985 {
4986 arg1 = &temp1;
4987 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4988 }
4989 {
4990 arg2 = &temp2;
4991 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4992 }
4993 {
4994 PyThreadState* __tstate = wxPyBeginAllowThreads();
4995 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4996
4997 wxPyEndAllowThreads(__tstate);
4998 if (PyErr_Occurred()) SWIG_fail;
4999 }
5000 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5001 return resultobj;
5002 fail:
5003 return NULL;
5004 }
5005
5006
5007 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
5008 PyObject *resultobj = NULL;
5009 wxPoint *arg1 = 0 ;
5010 wxSize *arg2 = 0 ;
5011 wxRect *result;
5012 wxPoint temp1 ;
5013 wxSize temp2 ;
5014 PyObject * obj0 = 0 ;
5015 PyObject * obj1 = 0 ;
5016 char *kwnames[] = {
5017 (char *) "pos",(char *) "size", NULL
5018 };
5019
5020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
5021 {
5022 arg1 = &temp1;
5023 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5024 }
5025 {
5026 arg2 = &temp2;
5027 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5028 }
5029 {
5030 PyThreadState* __tstate = wxPyBeginAllowThreads();
5031 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
5032
5033 wxPyEndAllowThreads(__tstate);
5034 if (PyErr_Occurred()) SWIG_fail;
5035 }
5036 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5037 return resultobj;
5038 fail:
5039 return NULL;
5040 }
5041
5042
5043 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
5044 PyObject *resultobj = NULL;
5045 wxSize *arg1 = 0 ;
5046 wxRect *result;
5047 wxSize temp1 ;
5048 PyObject * obj0 = 0 ;
5049 char *kwnames[] = {
5050 (char *) "size", NULL
5051 };
5052
5053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
5054 {
5055 arg1 = &temp1;
5056 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
5057 }
5058 {
5059 PyThreadState* __tstate = wxPyBeginAllowThreads();
5060 result = (wxRect *)new wxRect((wxSize const &)*arg1);
5061
5062 wxPyEndAllowThreads(__tstate);
5063 if (PyErr_Occurred()) SWIG_fail;
5064 }
5065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5066 return resultobj;
5067 fail:
5068 return NULL;
5069 }
5070
5071
5072 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
5073 PyObject *resultobj = NULL;
5074 wxRect *arg1 = (wxRect *) 0 ;
5075 PyObject * obj0 = 0 ;
5076 char *kwnames[] = {
5077 (char *) "self", NULL
5078 };
5079
5080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
5081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5082 if (SWIG_arg_fail(1)) SWIG_fail;
5083 {
5084 PyThreadState* __tstate = wxPyBeginAllowThreads();
5085 delete arg1;
5086
5087 wxPyEndAllowThreads(__tstate);
5088 if (PyErr_Occurred()) SWIG_fail;
5089 }
5090 Py_INCREF(Py_None); resultobj = Py_None;
5091 return resultobj;
5092 fail:
5093 return NULL;
5094 }
5095
5096
5097 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
5098 PyObject *resultobj = NULL;
5099 wxRect *arg1 = (wxRect *) 0 ;
5100 int result;
5101 PyObject * obj0 = 0 ;
5102 char *kwnames[] = {
5103 (char *) "self", NULL
5104 };
5105
5106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
5107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5108 if (SWIG_arg_fail(1)) SWIG_fail;
5109 {
5110 PyThreadState* __tstate = wxPyBeginAllowThreads();
5111 result = (int)((wxRect const *)arg1)->GetX();
5112
5113 wxPyEndAllowThreads(__tstate);
5114 if (PyErr_Occurred()) SWIG_fail;
5115 }
5116 {
5117 resultobj = SWIG_From_int(static_cast<int >(result));
5118 }
5119 return resultobj;
5120 fail:
5121 return NULL;
5122 }
5123
5124
5125 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
5126 PyObject *resultobj = NULL;
5127 wxRect *arg1 = (wxRect *) 0 ;
5128 int arg2 ;
5129 PyObject * obj0 = 0 ;
5130 PyObject * obj1 = 0 ;
5131 char *kwnames[] = {
5132 (char *) "self",(char *) "x", NULL
5133 };
5134
5135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
5136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5137 if (SWIG_arg_fail(1)) SWIG_fail;
5138 {
5139 arg2 = static_cast<int >(SWIG_As_int(obj1));
5140 if (SWIG_arg_fail(2)) SWIG_fail;
5141 }
5142 {
5143 PyThreadState* __tstate = wxPyBeginAllowThreads();
5144 (arg1)->SetX(arg2);
5145
5146 wxPyEndAllowThreads(__tstate);
5147 if (PyErr_Occurred()) SWIG_fail;
5148 }
5149 Py_INCREF(Py_None); resultobj = Py_None;
5150 return resultobj;
5151 fail:
5152 return NULL;
5153 }
5154
5155
5156 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5157 PyObject *resultobj = NULL;
5158 wxRect *arg1 = (wxRect *) 0 ;
5159 int result;
5160 PyObject * obj0 = 0 ;
5161 char *kwnames[] = {
5162 (char *) "self", NULL
5163 };
5164
5165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5167 if (SWIG_arg_fail(1)) SWIG_fail;
5168 {
5169 PyThreadState* __tstate = wxPyBeginAllowThreads();
5170 result = (int)(arg1)->GetY();
5171
5172 wxPyEndAllowThreads(__tstate);
5173 if (PyErr_Occurred()) SWIG_fail;
5174 }
5175 {
5176 resultobj = SWIG_From_int(static_cast<int >(result));
5177 }
5178 return resultobj;
5179 fail:
5180 return NULL;
5181 }
5182
5183
5184 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5185 PyObject *resultobj = NULL;
5186 wxRect *arg1 = (wxRect *) 0 ;
5187 int arg2 ;
5188 PyObject * obj0 = 0 ;
5189 PyObject * obj1 = 0 ;
5190 char *kwnames[] = {
5191 (char *) "self",(char *) "y", NULL
5192 };
5193
5194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5196 if (SWIG_arg_fail(1)) SWIG_fail;
5197 {
5198 arg2 = static_cast<int >(SWIG_As_int(obj1));
5199 if (SWIG_arg_fail(2)) SWIG_fail;
5200 }
5201 {
5202 PyThreadState* __tstate = wxPyBeginAllowThreads();
5203 (arg1)->SetY(arg2);
5204
5205 wxPyEndAllowThreads(__tstate);
5206 if (PyErr_Occurred()) SWIG_fail;
5207 }
5208 Py_INCREF(Py_None); resultobj = Py_None;
5209 return resultobj;
5210 fail:
5211 return NULL;
5212 }
5213
5214
5215 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5216 PyObject *resultobj = NULL;
5217 wxRect *arg1 = (wxRect *) 0 ;
5218 int result;
5219 PyObject * obj0 = 0 ;
5220 char *kwnames[] = {
5221 (char *) "self", NULL
5222 };
5223
5224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5226 if (SWIG_arg_fail(1)) SWIG_fail;
5227 {
5228 PyThreadState* __tstate = wxPyBeginAllowThreads();
5229 result = (int)((wxRect const *)arg1)->GetWidth();
5230
5231 wxPyEndAllowThreads(__tstate);
5232 if (PyErr_Occurred()) SWIG_fail;
5233 }
5234 {
5235 resultobj = SWIG_From_int(static_cast<int >(result));
5236 }
5237 return resultobj;
5238 fail:
5239 return NULL;
5240 }
5241
5242
5243 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5244 PyObject *resultobj = NULL;
5245 wxRect *arg1 = (wxRect *) 0 ;
5246 int arg2 ;
5247 PyObject * obj0 = 0 ;
5248 PyObject * obj1 = 0 ;
5249 char *kwnames[] = {
5250 (char *) "self",(char *) "w", NULL
5251 };
5252
5253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5255 if (SWIG_arg_fail(1)) SWIG_fail;
5256 {
5257 arg2 = static_cast<int >(SWIG_As_int(obj1));
5258 if (SWIG_arg_fail(2)) SWIG_fail;
5259 }
5260 {
5261 PyThreadState* __tstate = wxPyBeginAllowThreads();
5262 (arg1)->SetWidth(arg2);
5263
5264 wxPyEndAllowThreads(__tstate);
5265 if (PyErr_Occurred()) SWIG_fail;
5266 }
5267 Py_INCREF(Py_None); resultobj = Py_None;
5268 return resultobj;
5269 fail:
5270 return NULL;
5271 }
5272
5273
5274 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5275 PyObject *resultobj = NULL;
5276 wxRect *arg1 = (wxRect *) 0 ;
5277 int result;
5278 PyObject * obj0 = 0 ;
5279 char *kwnames[] = {
5280 (char *) "self", NULL
5281 };
5282
5283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5285 if (SWIG_arg_fail(1)) SWIG_fail;
5286 {
5287 PyThreadState* __tstate = wxPyBeginAllowThreads();
5288 result = (int)((wxRect const *)arg1)->GetHeight();
5289
5290 wxPyEndAllowThreads(__tstate);
5291 if (PyErr_Occurred()) SWIG_fail;
5292 }
5293 {
5294 resultobj = SWIG_From_int(static_cast<int >(result));
5295 }
5296 return resultobj;
5297 fail:
5298 return NULL;
5299 }
5300
5301
5302 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5303 PyObject *resultobj = NULL;
5304 wxRect *arg1 = (wxRect *) 0 ;
5305 int arg2 ;
5306 PyObject * obj0 = 0 ;
5307 PyObject * obj1 = 0 ;
5308 char *kwnames[] = {
5309 (char *) "self",(char *) "h", NULL
5310 };
5311
5312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5314 if (SWIG_arg_fail(1)) SWIG_fail;
5315 {
5316 arg2 = static_cast<int >(SWIG_As_int(obj1));
5317 if (SWIG_arg_fail(2)) SWIG_fail;
5318 }
5319 {
5320 PyThreadState* __tstate = wxPyBeginAllowThreads();
5321 (arg1)->SetHeight(arg2);
5322
5323 wxPyEndAllowThreads(__tstate);
5324 if (PyErr_Occurred()) SWIG_fail;
5325 }
5326 Py_INCREF(Py_None); resultobj = Py_None;
5327 return resultobj;
5328 fail:
5329 return NULL;
5330 }
5331
5332
5333 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5334 PyObject *resultobj = NULL;
5335 wxRect *arg1 = (wxRect *) 0 ;
5336 wxPoint result;
5337 PyObject * obj0 = 0 ;
5338 char *kwnames[] = {
5339 (char *) "self", NULL
5340 };
5341
5342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5344 if (SWIG_arg_fail(1)) SWIG_fail;
5345 {
5346 PyThreadState* __tstate = wxPyBeginAllowThreads();
5347 result = ((wxRect const *)arg1)->GetPosition();
5348
5349 wxPyEndAllowThreads(__tstate);
5350 if (PyErr_Occurred()) SWIG_fail;
5351 }
5352 {
5353 wxPoint * resultptr;
5354 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5355 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5356 }
5357 return resultobj;
5358 fail:
5359 return NULL;
5360 }
5361
5362
5363 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5364 PyObject *resultobj = NULL;
5365 wxRect *arg1 = (wxRect *) 0 ;
5366 wxPoint *arg2 = 0 ;
5367 wxPoint temp2 ;
5368 PyObject * obj0 = 0 ;
5369 PyObject * obj1 = 0 ;
5370 char *kwnames[] = {
5371 (char *) "self",(char *) "p", NULL
5372 };
5373
5374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5376 if (SWIG_arg_fail(1)) SWIG_fail;
5377 {
5378 arg2 = &temp2;
5379 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5380 }
5381 {
5382 PyThreadState* __tstate = wxPyBeginAllowThreads();
5383 (arg1)->SetPosition((wxPoint const &)*arg2);
5384
5385 wxPyEndAllowThreads(__tstate);
5386 if (PyErr_Occurred()) SWIG_fail;
5387 }
5388 Py_INCREF(Py_None); resultobj = Py_None;
5389 return resultobj;
5390 fail:
5391 return NULL;
5392 }
5393
5394
5395 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5396 PyObject *resultobj = NULL;
5397 wxRect *arg1 = (wxRect *) 0 ;
5398 wxSize result;
5399 PyObject * obj0 = 0 ;
5400 char *kwnames[] = {
5401 (char *) "self", NULL
5402 };
5403
5404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5406 if (SWIG_arg_fail(1)) SWIG_fail;
5407 {
5408 PyThreadState* __tstate = wxPyBeginAllowThreads();
5409 result = ((wxRect const *)arg1)->GetSize();
5410
5411 wxPyEndAllowThreads(__tstate);
5412 if (PyErr_Occurred()) SWIG_fail;
5413 }
5414 {
5415 wxSize * resultptr;
5416 resultptr = new wxSize(static_cast<wxSize & >(result));
5417 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5418 }
5419 return resultobj;
5420 fail:
5421 return NULL;
5422 }
5423
5424
5425 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5426 PyObject *resultobj = NULL;
5427 wxRect *arg1 = (wxRect *) 0 ;
5428 wxSize *arg2 = 0 ;
5429 wxSize temp2 ;
5430 PyObject * obj0 = 0 ;
5431 PyObject * obj1 = 0 ;
5432 char *kwnames[] = {
5433 (char *) "self",(char *) "s", NULL
5434 };
5435
5436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5438 if (SWIG_arg_fail(1)) SWIG_fail;
5439 {
5440 arg2 = &temp2;
5441 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5442 }
5443 {
5444 PyThreadState* __tstate = wxPyBeginAllowThreads();
5445 (arg1)->SetSize((wxSize const &)*arg2);
5446
5447 wxPyEndAllowThreads(__tstate);
5448 if (PyErr_Occurred()) SWIG_fail;
5449 }
5450 Py_INCREF(Py_None); resultobj = Py_None;
5451 return resultobj;
5452 fail:
5453 return NULL;
5454 }
5455
5456
5457 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5458 PyObject *resultobj = NULL;
5459 wxRect *arg1 = (wxRect *) 0 ;
5460 bool result;
5461 PyObject * obj0 = 0 ;
5462 char *kwnames[] = {
5463 (char *) "self", NULL
5464 };
5465
5466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5468 if (SWIG_arg_fail(1)) SWIG_fail;
5469 {
5470 PyThreadState* __tstate = wxPyBeginAllowThreads();
5471 result = (bool)((wxRect const *)arg1)->IsEmpty();
5472
5473 wxPyEndAllowThreads(__tstate);
5474 if (PyErr_Occurred()) SWIG_fail;
5475 }
5476 {
5477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5478 }
5479 return resultobj;
5480 fail:
5481 return NULL;
5482 }
5483
5484
5485 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5486 PyObject *resultobj = NULL;
5487 wxRect *arg1 = (wxRect *) 0 ;
5488 wxPoint result;
5489 PyObject * obj0 = 0 ;
5490 char *kwnames[] = {
5491 (char *) "self", NULL
5492 };
5493
5494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5496 if (SWIG_arg_fail(1)) SWIG_fail;
5497 {
5498 PyThreadState* __tstate = wxPyBeginAllowThreads();
5499 result = ((wxRect const *)arg1)->GetTopLeft();
5500
5501 wxPyEndAllowThreads(__tstate);
5502 if (PyErr_Occurred()) SWIG_fail;
5503 }
5504 {
5505 wxPoint * resultptr;
5506 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5507 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5508 }
5509 return resultobj;
5510 fail:
5511 return NULL;
5512 }
5513
5514
5515 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5516 PyObject *resultobj = NULL;
5517 wxRect *arg1 = (wxRect *) 0 ;
5518 wxPoint *arg2 = 0 ;
5519 wxPoint temp2 ;
5520 PyObject * obj0 = 0 ;
5521 PyObject * obj1 = 0 ;
5522 char *kwnames[] = {
5523 (char *) "self",(char *) "p", NULL
5524 };
5525
5526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5528 if (SWIG_arg_fail(1)) SWIG_fail;
5529 {
5530 arg2 = &temp2;
5531 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5532 }
5533 {
5534 PyThreadState* __tstate = wxPyBeginAllowThreads();
5535 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5536
5537 wxPyEndAllowThreads(__tstate);
5538 if (PyErr_Occurred()) SWIG_fail;
5539 }
5540 Py_INCREF(Py_None); resultobj = Py_None;
5541 return resultobj;
5542 fail:
5543 return NULL;
5544 }
5545
5546
5547 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5548 PyObject *resultobj = NULL;
5549 wxRect *arg1 = (wxRect *) 0 ;
5550 wxPoint result;
5551 PyObject * obj0 = 0 ;
5552 char *kwnames[] = {
5553 (char *) "self", NULL
5554 };
5555
5556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5558 if (SWIG_arg_fail(1)) SWIG_fail;
5559 {
5560 PyThreadState* __tstate = wxPyBeginAllowThreads();
5561 result = ((wxRect const *)arg1)->GetBottomRight();
5562
5563 wxPyEndAllowThreads(__tstate);
5564 if (PyErr_Occurred()) SWIG_fail;
5565 }
5566 {
5567 wxPoint * resultptr;
5568 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5569 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5570 }
5571 return resultobj;
5572 fail:
5573 return NULL;
5574 }
5575
5576
5577 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5578 PyObject *resultobj = NULL;
5579 wxRect *arg1 = (wxRect *) 0 ;
5580 wxPoint *arg2 = 0 ;
5581 wxPoint temp2 ;
5582 PyObject * obj0 = 0 ;
5583 PyObject * obj1 = 0 ;
5584 char *kwnames[] = {
5585 (char *) "self",(char *) "p", NULL
5586 };
5587
5588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5590 if (SWIG_arg_fail(1)) SWIG_fail;
5591 {
5592 arg2 = &temp2;
5593 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5594 }
5595 {
5596 PyThreadState* __tstate = wxPyBeginAllowThreads();
5597 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5598
5599 wxPyEndAllowThreads(__tstate);
5600 if (PyErr_Occurred()) SWIG_fail;
5601 }
5602 Py_INCREF(Py_None); resultobj = Py_None;
5603 return resultobj;
5604 fail:
5605 return NULL;
5606 }
5607
5608
5609 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5610 PyObject *resultobj = NULL;
5611 wxRect *arg1 = (wxRect *) 0 ;
5612 int result;
5613 PyObject * obj0 = 0 ;
5614 char *kwnames[] = {
5615 (char *) "self", NULL
5616 };
5617
5618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5620 if (SWIG_arg_fail(1)) SWIG_fail;
5621 {
5622 PyThreadState* __tstate = wxPyBeginAllowThreads();
5623 result = (int)((wxRect const *)arg1)->GetLeft();
5624
5625 wxPyEndAllowThreads(__tstate);
5626 if (PyErr_Occurred()) SWIG_fail;
5627 }
5628 {
5629 resultobj = SWIG_From_int(static_cast<int >(result));
5630 }
5631 return resultobj;
5632 fail:
5633 return NULL;
5634 }
5635
5636
5637 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5638 PyObject *resultobj = NULL;
5639 wxRect *arg1 = (wxRect *) 0 ;
5640 int result;
5641 PyObject * obj0 = 0 ;
5642 char *kwnames[] = {
5643 (char *) "self", NULL
5644 };
5645
5646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5648 if (SWIG_arg_fail(1)) SWIG_fail;
5649 {
5650 PyThreadState* __tstate = wxPyBeginAllowThreads();
5651 result = (int)((wxRect const *)arg1)->GetTop();
5652
5653 wxPyEndAllowThreads(__tstate);
5654 if (PyErr_Occurred()) SWIG_fail;
5655 }
5656 {
5657 resultobj = SWIG_From_int(static_cast<int >(result));
5658 }
5659 return resultobj;
5660 fail:
5661 return NULL;
5662 }
5663
5664
5665 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5666 PyObject *resultobj = NULL;
5667 wxRect *arg1 = (wxRect *) 0 ;
5668 int result;
5669 PyObject * obj0 = 0 ;
5670 char *kwnames[] = {
5671 (char *) "self", NULL
5672 };
5673
5674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5676 if (SWIG_arg_fail(1)) SWIG_fail;
5677 {
5678 PyThreadState* __tstate = wxPyBeginAllowThreads();
5679 result = (int)((wxRect const *)arg1)->GetBottom();
5680
5681 wxPyEndAllowThreads(__tstate);
5682 if (PyErr_Occurred()) SWIG_fail;
5683 }
5684 {
5685 resultobj = SWIG_From_int(static_cast<int >(result));
5686 }
5687 return resultobj;
5688 fail:
5689 return NULL;
5690 }
5691
5692
5693 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5694 PyObject *resultobj = NULL;
5695 wxRect *arg1 = (wxRect *) 0 ;
5696 int result;
5697 PyObject * obj0 = 0 ;
5698 char *kwnames[] = {
5699 (char *) "self", NULL
5700 };
5701
5702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5704 if (SWIG_arg_fail(1)) SWIG_fail;
5705 {
5706 PyThreadState* __tstate = wxPyBeginAllowThreads();
5707 result = (int)((wxRect const *)arg1)->GetRight();
5708
5709 wxPyEndAllowThreads(__tstate);
5710 if (PyErr_Occurred()) SWIG_fail;
5711 }
5712 {
5713 resultobj = SWIG_From_int(static_cast<int >(result));
5714 }
5715 return resultobj;
5716 fail:
5717 return NULL;
5718 }
5719
5720
5721 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5722 PyObject *resultobj = NULL;
5723 wxRect *arg1 = (wxRect *) 0 ;
5724 int arg2 ;
5725 PyObject * obj0 = 0 ;
5726 PyObject * obj1 = 0 ;
5727 char *kwnames[] = {
5728 (char *) "self",(char *) "left", NULL
5729 };
5730
5731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5733 if (SWIG_arg_fail(1)) SWIG_fail;
5734 {
5735 arg2 = static_cast<int >(SWIG_As_int(obj1));
5736 if (SWIG_arg_fail(2)) SWIG_fail;
5737 }
5738 {
5739 PyThreadState* __tstate = wxPyBeginAllowThreads();
5740 (arg1)->SetLeft(arg2);
5741
5742 wxPyEndAllowThreads(__tstate);
5743 if (PyErr_Occurred()) SWIG_fail;
5744 }
5745 Py_INCREF(Py_None); resultobj = Py_None;
5746 return resultobj;
5747 fail:
5748 return NULL;
5749 }
5750
5751
5752 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5753 PyObject *resultobj = NULL;
5754 wxRect *arg1 = (wxRect *) 0 ;
5755 int arg2 ;
5756 PyObject * obj0 = 0 ;
5757 PyObject * obj1 = 0 ;
5758 char *kwnames[] = {
5759 (char *) "self",(char *) "right", NULL
5760 };
5761
5762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5764 if (SWIG_arg_fail(1)) SWIG_fail;
5765 {
5766 arg2 = static_cast<int >(SWIG_As_int(obj1));
5767 if (SWIG_arg_fail(2)) SWIG_fail;
5768 }
5769 {
5770 PyThreadState* __tstate = wxPyBeginAllowThreads();
5771 (arg1)->SetRight(arg2);
5772
5773 wxPyEndAllowThreads(__tstate);
5774 if (PyErr_Occurred()) SWIG_fail;
5775 }
5776 Py_INCREF(Py_None); resultobj = Py_None;
5777 return resultobj;
5778 fail:
5779 return NULL;
5780 }
5781
5782
5783 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5784 PyObject *resultobj = NULL;
5785 wxRect *arg1 = (wxRect *) 0 ;
5786 int arg2 ;
5787 PyObject * obj0 = 0 ;
5788 PyObject * obj1 = 0 ;
5789 char *kwnames[] = {
5790 (char *) "self",(char *) "top", NULL
5791 };
5792
5793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5795 if (SWIG_arg_fail(1)) SWIG_fail;
5796 {
5797 arg2 = static_cast<int >(SWIG_As_int(obj1));
5798 if (SWIG_arg_fail(2)) SWIG_fail;
5799 }
5800 {
5801 PyThreadState* __tstate = wxPyBeginAllowThreads();
5802 (arg1)->SetTop(arg2);
5803
5804 wxPyEndAllowThreads(__tstate);
5805 if (PyErr_Occurred()) SWIG_fail;
5806 }
5807 Py_INCREF(Py_None); resultobj = Py_None;
5808 return resultobj;
5809 fail:
5810 return NULL;
5811 }
5812
5813
5814 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5815 PyObject *resultobj = NULL;
5816 wxRect *arg1 = (wxRect *) 0 ;
5817 int arg2 ;
5818 PyObject * obj0 = 0 ;
5819 PyObject * obj1 = 0 ;
5820 char *kwnames[] = {
5821 (char *) "self",(char *) "bottom", NULL
5822 };
5823
5824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5826 if (SWIG_arg_fail(1)) SWIG_fail;
5827 {
5828 arg2 = static_cast<int >(SWIG_As_int(obj1));
5829 if (SWIG_arg_fail(2)) SWIG_fail;
5830 }
5831 {
5832 PyThreadState* __tstate = wxPyBeginAllowThreads();
5833 (arg1)->SetBottom(arg2);
5834
5835 wxPyEndAllowThreads(__tstate);
5836 if (PyErr_Occurred()) SWIG_fail;
5837 }
5838 Py_INCREF(Py_None); resultobj = Py_None;
5839 return resultobj;
5840 fail:
5841 return NULL;
5842 }
5843
5844
5845 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5846 PyObject *resultobj = NULL;
5847 wxRect *arg1 = (wxRect *) 0 ;
5848 int arg2 ;
5849 int arg3 ;
5850 wxRect *result;
5851 PyObject * obj0 = 0 ;
5852 PyObject * obj1 = 0 ;
5853 PyObject * obj2 = 0 ;
5854 char *kwnames[] = {
5855 (char *) "self",(char *) "dx",(char *) "dy", NULL
5856 };
5857
5858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5860 if (SWIG_arg_fail(1)) SWIG_fail;
5861 {
5862 arg2 = static_cast<int >(SWIG_As_int(obj1));
5863 if (SWIG_arg_fail(2)) SWIG_fail;
5864 }
5865 {
5866 arg3 = static_cast<int >(SWIG_As_int(obj2));
5867 if (SWIG_arg_fail(3)) SWIG_fail;
5868 }
5869 {
5870 PyThreadState* __tstate = wxPyBeginAllowThreads();
5871 {
5872 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5873 result = (wxRect *) &_result_ref;
5874 }
5875
5876 wxPyEndAllowThreads(__tstate);
5877 if (PyErr_Occurred()) SWIG_fail;
5878 }
5879 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5880 return resultobj;
5881 fail:
5882 return NULL;
5883 }
5884
5885
5886 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5887 PyObject *resultobj = NULL;
5888 wxRect *arg1 = (wxRect *) 0 ;
5889 int arg2 ;
5890 int arg3 ;
5891 wxRect *result;
5892 PyObject * obj0 = 0 ;
5893 PyObject * obj1 = 0 ;
5894 PyObject * obj2 = 0 ;
5895 char *kwnames[] = {
5896 (char *) "self",(char *) "dx",(char *) "dy", NULL
5897 };
5898
5899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5901 if (SWIG_arg_fail(1)) SWIG_fail;
5902 {
5903 arg2 = static_cast<int >(SWIG_As_int(obj1));
5904 if (SWIG_arg_fail(2)) SWIG_fail;
5905 }
5906 {
5907 arg3 = static_cast<int >(SWIG_As_int(obj2));
5908 if (SWIG_arg_fail(3)) SWIG_fail;
5909 }
5910 {
5911 PyThreadState* __tstate = wxPyBeginAllowThreads();
5912 {
5913 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5914 result = (wxRect *) &_result_ref;
5915 }
5916
5917 wxPyEndAllowThreads(__tstate);
5918 if (PyErr_Occurred()) SWIG_fail;
5919 }
5920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5921 return resultobj;
5922 fail:
5923 return NULL;
5924 }
5925
5926
5927 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5928 PyObject *resultobj = NULL;
5929 wxRect *arg1 = (wxRect *) 0 ;
5930 int arg2 ;
5931 int arg3 ;
5932 PyObject * obj0 = 0 ;
5933 PyObject * obj1 = 0 ;
5934 PyObject * obj2 = 0 ;
5935 char *kwnames[] = {
5936 (char *) "self",(char *) "dx",(char *) "dy", NULL
5937 };
5938
5939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5941 if (SWIG_arg_fail(1)) SWIG_fail;
5942 {
5943 arg2 = static_cast<int >(SWIG_As_int(obj1));
5944 if (SWIG_arg_fail(2)) SWIG_fail;
5945 }
5946 {
5947 arg3 = static_cast<int >(SWIG_As_int(obj2));
5948 if (SWIG_arg_fail(3)) SWIG_fail;
5949 }
5950 {
5951 PyThreadState* __tstate = wxPyBeginAllowThreads();
5952 (arg1)->Offset(arg2,arg3);
5953
5954 wxPyEndAllowThreads(__tstate);
5955 if (PyErr_Occurred()) SWIG_fail;
5956 }
5957 Py_INCREF(Py_None); resultobj = Py_None;
5958 return resultobj;
5959 fail:
5960 return NULL;
5961 }
5962
5963
5964 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5965 PyObject *resultobj = NULL;
5966 wxRect *arg1 = (wxRect *) 0 ;
5967 wxPoint *arg2 = 0 ;
5968 wxPoint temp2 ;
5969 PyObject * obj0 = 0 ;
5970 PyObject * obj1 = 0 ;
5971 char *kwnames[] = {
5972 (char *) "self",(char *) "pt", NULL
5973 };
5974
5975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5977 if (SWIG_arg_fail(1)) SWIG_fail;
5978 {
5979 arg2 = &temp2;
5980 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5981 }
5982 {
5983 PyThreadState* __tstate = wxPyBeginAllowThreads();
5984 (arg1)->Offset((wxPoint const &)*arg2);
5985
5986 wxPyEndAllowThreads(__tstate);
5987 if (PyErr_Occurred()) SWIG_fail;
5988 }
5989 Py_INCREF(Py_None); resultobj = Py_None;
5990 return resultobj;
5991 fail:
5992 return NULL;
5993 }
5994
5995
5996 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5997 PyObject *resultobj = NULL;
5998 wxRect *arg1 = (wxRect *) 0 ;
5999 wxRect *arg2 = 0 ;
6000 wxRect result;
6001 wxRect temp2 ;
6002 PyObject * obj0 = 0 ;
6003 PyObject * obj1 = 0 ;
6004 char *kwnames[] = {
6005 (char *) "self",(char *) "rect", NULL
6006 };
6007
6008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
6009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6010 if (SWIG_arg_fail(1)) SWIG_fail;
6011 {
6012 arg2 = &temp2;
6013 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6014 }
6015 {
6016 PyThreadState* __tstate = wxPyBeginAllowThreads();
6017 result = (arg1)->Intersect((wxRect const &)*arg2);
6018
6019 wxPyEndAllowThreads(__tstate);
6020 if (PyErr_Occurred()) SWIG_fail;
6021 }
6022 {
6023 wxRect * resultptr;
6024 resultptr = new wxRect(static_cast<wxRect & >(result));
6025 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6026 }
6027 return resultobj;
6028 fail:
6029 return NULL;
6030 }
6031
6032
6033 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6034 PyObject *resultobj = NULL;
6035 wxRect *arg1 = (wxRect *) 0 ;
6036 wxRect *arg2 = 0 ;
6037 wxRect result;
6038 wxRect temp2 ;
6039 PyObject * obj0 = 0 ;
6040 PyObject * obj1 = 0 ;
6041 char *kwnames[] = {
6042 (char *) "self",(char *) "rect", NULL
6043 };
6044
6045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
6046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6047 if (SWIG_arg_fail(1)) SWIG_fail;
6048 {
6049 arg2 = &temp2;
6050 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6051 }
6052 {
6053 PyThreadState* __tstate = wxPyBeginAllowThreads();
6054 result = (arg1)->Union((wxRect const &)*arg2);
6055
6056 wxPyEndAllowThreads(__tstate);
6057 if (PyErr_Occurred()) SWIG_fail;
6058 }
6059 {
6060 wxRect * resultptr;
6061 resultptr = new wxRect(static_cast<wxRect & >(result));
6062 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6063 }
6064 return resultobj;
6065 fail:
6066 return NULL;
6067 }
6068
6069
6070 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
6071 PyObject *resultobj = NULL;
6072 wxRect *arg1 = (wxRect *) 0 ;
6073 wxRect *arg2 = 0 ;
6074 wxRect result;
6075 wxRect temp2 ;
6076 PyObject * obj0 = 0 ;
6077 PyObject * obj1 = 0 ;
6078 char *kwnames[] = {
6079 (char *) "self",(char *) "rect", NULL
6080 };
6081
6082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
6083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6084 if (SWIG_arg_fail(1)) SWIG_fail;
6085 {
6086 arg2 = &temp2;
6087 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6088 }
6089 {
6090 PyThreadState* __tstate = wxPyBeginAllowThreads();
6091 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
6092
6093 wxPyEndAllowThreads(__tstate);
6094 if (PyErr_Occurred()) SWIG_fail;
6095 }
6096 {
6097 wxRect * resultptr;
6098 resultptr = new wxRect(static_cast<wxRect & >(result));
6099 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6100 }
6101 return resultobj;
6102 fail:
6103 return NULL;
6104 }
6105
6106
6107 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6108 PyObject *resultobj = NULL;
6109 wxRect *arg1 = (wxRect *) 0 ;
6110 wxRect *arg2 = 0 ;
6111 wxRect *result;
6112 wxRect temp2 ;
6113 PyObject * obj0 = 0 ;
6114 PyObject * obj1 = 0 ;
6115 char *kwnames[] = {
6116 (char *) "self",(char *) "rect", NULL
6117 };
6118
6119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
6120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6121 if (SWIG_arg_fail(1)) SWIG_fail;
6122 {
6123 arg2 = &temp2;
6124 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6125 }
6126 {
6127 PyThreadState* __tstate = wxPyBeginAllowThreads();
6128 {
6129 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
6130 result = (wxRect *) &_result_ref;
6131 }
6132
6133 wxPyEndAllowThreads(__tstate);
6134 if (PyErr_Occurred()) SWIG_fail;
6135 }
6136 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
6137 return resultobj;
6138 fail:
6139 return NULL;
6140 }
6141
6142
6143 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6144 PyObject *resultobj = NULL;
6145 wxRect *arg1 = (wxRect *) 0 ;
6146 wxRect *arg2 = 0 ;
6147 bool result;
6148 wxRect temp2 ;
6149 PyObject * obj0 = 0 ;
6150 PyObject * obj1 = 0 ;
6151 char *kwnames[] = {
6152 (char *) "self",(char *) "rect", NULL
6153 };
6154
6155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6157 if (SWIG_arg_fail(1)) SWIG_fail;
6158 {
6159 arg2 = &temp2;
6160 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6161 }
6162 {
6163 PyThreadState* __tstate = wxPyBeginAllowThreads();
6164 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6165
6166 wxPyEndAllowThreads(__tstate);
6167 if (PyErr_Occurred()) SWIG_fail;
6168 }
6169 {
6170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6171 }
6172 return resultobj;
6173 fail:
6174 return NULL;
6175 }
6176
6177
6178 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6179 PyObject *resultobj = NULL;
6180 wxRect *arg1 = (wxRect *) 0 ;
6181 wxRect *arg2 = 0 ;
6182 bool result;
6183 wxRect temp2 ;
6184 PyObject * obj0 = 0 ;
6185 PyObject * obj1 = 0 ;
6186 char *kwnames[] = {
6187 (char *) "self",(char *) "rect", NULL
6188 };
6189
6190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6192 if (SWIG_arg_fail(1)) SWIG_fail;
6193 {
6194 arg2 = &temp2;
6195 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6196 }
6197 {
6198 PyThreadState* __tstate = wxPyBeginAllowThreads();
6199 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6200
6201 wxPyEndAllowThreads(__tstate);
6202 if (PyErr_Occurred()) SWIG_fail;
6203 }
6204 {
6205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6206 }
6207 return resultobj;
6208 fail:
6209 return NULL;
6210 }
6211
6212
6213 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6214 PyObject *resultobj = NULL;
6215 wxRect *arg1 = (wxRect *) 0 ;
6216 int arg2 ;
6217 int arg3 ;
6218 bool result;
6219 PyObject * obj0 = 0 ;
6220 PyObject * obj1 = 0 ;
6221 PyObject * obj2 = 0 ;
6222 char *kwnames[] = {
6223 (char *) "self",(char *) "x",(char *) "y", NULL
6224 };
6225
6226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6228 if (SWIG_arg_fail(1)) SWIG_fail;
6229 {
6230 arg2 = static_cast<int >(SWIG_As_int(obj1));
6231 if (SWIG_arg_fail(2)) SWIG_fail;
6232 }
6233 {
6234 arg3 = static_cast<int >(SWIG_As_int(obj2));
6235 if (SWIG_arg_fail(3)) SWIG_fail;
6236 }
6237 {
6238 PyThreadState* __tstate = wxPyBeginAllowThreads();
6239 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6240
6241 wxPyEndAllowThreads(__tstate);
6242 if (PyErr_Occurred()) SWIG_fail;
6243 }
6244 {
6245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6246 }
6247 return resultobj;
6248 fail:
6249 return NULL;
6250 }
6251
6252
6253 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6254 PyObject *resultobj = NULL;
6255 wxRect *arg1 = (wxRect *) 0 ;
6256 wxPoint *arg2 = 0 ;
6257 bool result;
6258 wxPoint temp2 ;
6259 PyObject * obj0 = 0 ;
6260 PyObject * obj1 = 0 ;
6261 char *kwnames[] = {
6262 (char *) "self",(char *) "pt", NULL
6263 };
6264
6265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6267 if (SWIG_arg_fail(1)) SWIG_fail;
6268 {
6269 arg2 = &temp2;
6270 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6271 }
6272 {
6273 PyThreadState* __tstate = wxPyBeginAllowThreads();
6274 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6275
6276 wxPyEndAllowThreads(__tstate);
6277 if (PyErr_Occurred()) SWIG_fail;
6278 }
6279 {
6280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6281 }
6282 return resultobj;
6283 fail:
6284 return NULL;
6285 }
6286
6287
6288 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6289 PyObject *resultobj = NULL;
6290 wxRect *arg1 = (wxRect *) 0 ;
6291 wxRect *arg2 = 0 ;
6292 bool result;
6293 wxRect temp2 ;
6294 PyObject * obj0 = 0 ;
6295 PyObject * obj1 = 0 ;
6296 char *kwnames[] = {
6297 (char *) "self",(char *) "rect", NULL
6298 };
6299
6300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6302 if (SWIG_arg_fail(1)) SWIG_fail;
6303 {
6304 arg2 = &temp2;
6305 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6306 }
6307 {
6308 PyThreadState* __tstate = wxPyBeginAllowThreads();
6309 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6310
6311 wxPyEndAllowThreads(__tstate);
6312 if (PyErr_Occurred()) SWIG_fail;
6313 }
6314 {
6315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6316 }
6317 return resultobj;
6318 fail:
6319 return NULL;
6320 }
6321
6322
6323 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6324 PyObject *resultobj = NULL;
6325 wxRect *arg1 = (wxRect *) 0 ;
6326 int arg2 ;
6327 PyObject * obj0 = 0 ;
6328 PyObject * obj1 = 0 ;
6329 char *kwnames[] = {
6330 (char *) "self",(char *) "x", NULL
6331 };
6332
6333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6335 if (SWIG_arg_fail(1)) SWIG_fail;
6336 {
6337 arg2 = static_cast<int >(SWIG_As_int(obj1));
6338 if (SWIG_arg_fail(2)) SWIG_fail;
6339 }
6340 if (arg1) (arg1)->x = arg2;
6341
6342 Py_INCREF(Py_None); resultobj = Py_None;
6343 return resultobj;
6344 fail:
6345 return NULL;
6346 }
6347
6348
6349 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6350 PyObject *resultobj = NULL;
6351 wxRect *arg1 = (wxRect *) 0 ;
6352 int result;
6353 PyObject * obj0 = 0 ;
6354 char *kwnames[] = {
6355 (char *) "self", NULL
6356 };
6357
6358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6360 if (SWIG_arg_fail(1)) SWIG_fail;
6361 result = (int) ((arg1)->x);
6362
6363 {
6364 resultobj = SWIG_From_int(static_cast<int >(result));
6365 }
6366 return resultobj;
6367 fail:
6368 return NULL;
6369 }
6370
6371
6372 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6373 PyObject *resultobj = NULL;
6374 wxRect *arg1 = (wxRect *) 0 ;
6375 int arg2 ;
6376 PyObject * obj0 = 0 ;
6377 PyObject * obj1 = 0 ;
6378 char *kwnames[] = {
6379 (char *) "self",(char *) "y", NULL
6380 };
6381
6382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6384 if (SWIG_arg_fail(1)) SWIG_fail;
6385 {
6386 arg2 = static_cast<int >(SWIG_As_int(obj1));
6387 if (SWIG_arg_fail(2)) SWIG_fail;
6388 }
6389 if (arg1) (arg1)->y = arg2;
6390
6391 Py_INCREF(Py_None); resultobj = Py_None;
6392 return resultobj;
6393 fail:
6394 return NULL;
6395 }
6396
6397
6398 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6399 PyObject *resultobj = NULL;
6400 wxRect *arg1 = (wxRect *) 0 ;
6401 int result;
6402 PyObject * obj0 = 0 ;
6403 char *kwnames[] = {
6404 (char *) "self", NULL
6405 };
6406
6407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6409 if (SWIG_arg_fail(1)) SWIG_fail;
6410 result = (int) ((arg1)->y);
6411
6412 {
6413 resultobj = SWIG_From_int(static_cast<int >(result));
6414 }
6415 return resultobj;
6416 fail:
6417 return NULL;
6418 }
6419
6420
6421 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6422 PyObject *resultobj = NULL;
6423 wxRect *arg1 = (wxRect *) 0 ;
6424 int arg2 ;
6425 PyObject * obj0 = 0 ;
6426 PyObject * obj1 = 0 ;
6427 char *kwnames[] = {
6428 (char *) "self",(char *) "width", NULL
6429 };
6430
6431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6433 if (SWIG_arg_fail(1)) SWIG_fail;
6434 {
6435 arg2 = static_cast<int >(SWIG_As_int(obj1));
6436 if (SWIG_arg_fail(2)) SWIG_fail;
6437 }
6438 if (arg1) (arg1)->width = arg2;
6439
6440 Py_INCREF(Py_None); resultobj = Py_None;
6441 return resultobj;
6442 fail:
6443 return NULL;
6444 }
6445
6446
6447 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6448 PyObject *resultobj = NULL;
6449 wxRect *arg1 = (wxRect *) 0 ;
6450 int result;
6451 PyObject * obj0 = 0 ;
6452 char *kwnames[] = {
6453 (char *) "self", NULL
6454 };
6455
6456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6458 if (SWIG_arg_fail(1)) SWIG_fail;
6459 result = (int) ((arg1)->width);
6460
6461 {
6462 resultobj = SWIG_From_int(static_cast<int >(result));
6463 }
6464 return resultobj;
6465 fail:
6466 return NULL;
6467 }
6468
6469
6470 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6471 PyObject *resultobj = NULL;
6472 wxRect *arg1 = (wxRect *) 0 ;
6473 int arg2 ;
6474 PyObject * obj0 = 0 ;
6475 PyObject * obj1 = 0 ;
6476 char *kwnames[] = {
6477 (char *) "self",(char *) "height", NULL
6478 };
6479
6480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6482 if (SWIG_arg_fail(1)) SWIG_fail;
6483 {
6484 arg2 = static_cast<int >(SWIG_As_int(obj1));
6485 if (SWIG_arg_fail(2)) SWIG_fail;
6486 }
6487 if (arg1) (arg1)->height = arg2;
6488
6489 Py_INCREF(Py_None); resultobj = Py_None;
6490 return resultobj;
6491 fail:
6492 return NULL;
6493 }
6494
6495
6496 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6497 PyObject *resultobj = NULL;
6498 wxRect *arg1 = (wxRect *) 0 ;
6499 int result;
6500 PyObject * obj0 = 0 ;
6501 char *kwnames[] = {
6502 (char *) "self", NULL
6503 };
6504
6505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6507 if (SWIG_arg_fail(1)) SWIG_fail;
6508 result = (int) ((arg1)->height);
6509
6510 {
6511 resultobj = SWIG_From_int(static_cast<int >(result));
6512 }
6513 return resultobj;
6514 fail:
6515 return NULL;
6516 }
6517
6518
6519 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6520 PyObject *resultobj = NULL;
6521 wxRect *arg1 = (wxRect *) 0 ;
6522 int arg2 = (int) 0 ;
6523 int arg3 = (int) 0 ;
6524 int arg4 = (int) 0 ;
6525 int arg5 = (int) 0 ;
6526 PyObject * obj0 = 0 ;
6527 PyObject * obj1 = 0 ;
6528 PyObject * obj2 = 0 ;
6529 PyObject * obj3 = 0 ;
6530 PyObject * obj4 = 0 ;
6531 char *kwnames[] = {
6532 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6533 };
6534
6535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6537 if (SWIG_arg_fail(1)) SWIG_fail;
6538 if (obj1) {
6539 {
6540 arg2 = static_cast<int >(SWIG_As_int(obj1));
6541 if (SWIG_arg_fail(2)) SWIG_fail;
6542 }
6543 }
6544 if (obj2) {
6545 {
6546 arg3 = static_cast<int >(SWIG_As_int(obj2));
6547 if (SWIG_arg_fail(3)) SWIG_fail;
6548 }
6549 }
6550 if (obj3) {
6551 {
6552 arg4 = static_cast<int >(SWIG_As_int(obj3));
6553 if (SWIG_arg_fail(4)) SWIG_fail;
6554 }
6555 }
6556 if (obj4) {
6557 {
6558 arg5 = static_cast<int >(SWIG_As_int(obj4));
6559 if (SWIG_arg_fail(5)) SWIG_fail;
6560 }
6561 }
6562 {
6563 PyThreadState* __tstate = wxPyBeginAllowThreads();
6564 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6565
6566 wxPyEndAllowThreads(__tstate);
6567 if (PyErr_Occurred()) SWIG_fail;
6568 }
6569 Py_INCREF(Py_None); resultobj = Py_None;
6570 return resultobj;
6571 fail:
6572 return NULL;
6573 }
6574
6575
6576 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6577 PyObject *resultobj = NULL;
6578 wxRect *arg1 = (wxRect *) 0 ;
6579 PyObject *result;
6580 PyObject * obj0 = 0 ;
6581 char *kwnames[] = {
6582 (char *) "self", NULL
6583 };
6584
6585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6587 if (SWIG_arg_fail(1)) SWIG_fail;
6588 {
6589 PyThreadState* __tstate = wxPyBeginAllowThreads();
6590 result = (PyObject *)wxRect_Get(arg1);
6591
6592 wxPyEndAllowThreads(__tstate);
6593 if (PyErr_Occurred()) SWIG_fail;
6594 }
6595 resultobj = result;
6596 return resultobj;
6597 fail:
6598 return NULL;
6599 }
6600
6601
6602 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6603 PyObject *obj;
6604 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6605 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6606 Py_INCREF(obj);
6607 return Py_BuildValue((char *)"");
6608 }
6609 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6610 PyObject *resultobj = NULL;
6611 wxRect *arg1 = (wxRect *) 0 ;
6612 wxRect *arg2 = (wxRect *) 0 ;
6613 PyObject *result;
6614 PyObject * obj0 = 0 ;
6615 PyObject * obj1 = 0 ;
6616 char *kwnames[] = {
6617 (char *) "r1",(char *) "r2", NULL
6618 };
6619
6620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6622 if (SWIG_arg_fail(1)) SWIG_fail;
6623 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6624 if (SWIG_arg_fail(2)) SWIG_fail;
6625 {
6626 if (!wxPyCheckForApp()) SWIG_fail;
6627 PyThreadState* __tstate = wxPyBeginAllowThreads();
6628 result = (PyObject *)wxIntersectRect(arg1,arg2);
6629
6630 wxPyEndAllowThreads(__tstate);
6631 if (PyErr_Occurred()) SWIG_fail;
6632 }
6633 resultobj = result;
6634 return resultobj;
6635 fail:
6636 return NULL;
6637 }
6638
6639
6640 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6641 PyObject *resultobj = NULL;
6642 double arg1 = (double) 0.0 ;
6643 double arg2 = (double) 0.0 ;
6644 wxPoint2D *result;
6645 PyObject * obj0 = 0 ;
6646 PyObject * obj1 = 0 ;
6647 char *kwnames[] = {
6648 (char *) "x",(char *) "y", NULL
6649 };
6650
6651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6652 if (obj0) {
6653 {
6654 arg1 = static_cast<double >(SWIG_As_double(obj0));
6655 if (SWIG_arg_fail(1)) SWIG_fail;
6656 }
6657 }
6658 if (obj1) {
6659 {
6660 arg2 = static_cast<double >(SWIG_As_double(obj1));
6661 if (SWIG_arg_fail(2)) SWIG_fail;
6662 }
6663 }
6664 {
6665 PyThreadState* __tstate = wxPyBeginAllowThreads();
6666 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6667
6668 wxPyEndAllowThreads(__tstate);
6669 if (PyErr_Occurred()) SWIG_fail;
6670 }
6671 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6672 return resultobj;
6673 fail:
6674 return NULL;
6675 }
6676
6677
6678 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6679 PyObject *resultobj = NULL;
6680 wxPoint2D *arg1 = 0 ;
6681 wxPoint2D *result;
6682 wxPoint2D temp1 ;
6683 PyObject * obj0 = 0 ;
6684 char *kwnames[] = {
6685 (char *) "pt", NULL
6686 };
6687
6688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6689 {
6690 arg1 = &temp1;
6691 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6692 }
6693 {
6694 PyThreadState* __tstate = wxPyBeginAllowThreads();
6695 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6696
6697 wxPyEndAllowThreads(__tstate);
6698 if (PyErr_Occurred()) SWIG_fail;
6699 }
6700 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6701 return resultobj;
6702 fail:
6703 return NULL;
6704 }
6705
6706
6707 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6708 PyObject *resultobj = NULL;
6709 wxPoint *arg1 = 0 ;
6710 wxPoint2D *result;
6711 wxPoint temp1 ;
6712 PyObject * obj0 = 0 ;
6713 char *kwnames[] = {
6714 (char *) "pt", NULL
6715 };
6716
6717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6718 {
6719 arg1 = &temp1;
6720 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6721 }
6722 {
6723 PyThreadState* __tstate = wxPyBeginAllowThreads();
6724 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6725
6726 wxPyEndAllowThreads(__tstate);
6727 if (PyErr_Occurred()) SWIG_fail;
6728 }
6729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6730 return resultobj;
6731 fail:
6732 return NULL;
6733 }
6734
6735
6736 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6737 PyObject *resultobj = NULL;
6738 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6739 int *arg2 = (int *) 0 ;
6740 int *arg3 = (int *) 0 ;
6741 int temp2 ;
6742 int res2 = 0 ;
6743 int temp3 ;
6744 int res3 = 0 ;
6745 PyObject * obj0 = 0 ;
6746 char *kwnames[] = {
6747 (char *) "self", NULL
6748 };
6749
6750 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6751 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6754 if (SWIG_arg_fail(1)) SWIG_fail;
6755 {
6756 PyThreadState* __tstate = wxPyBeginAllowThreads();
6757 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6758
6759 wxPyEndAllowThreads(__tstate);
6760 if (PyErr_Occurred()) SWIG_fail;
6761 }
6762 Py_INCREF(Py_None); resultobj = Py_None;
6763 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6764 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6765 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6766 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6767 return resultobj;
6768 fail:
6769 return NULL;
6770 }
6771
6772
6773 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6774 PyObject *resultobj = NULL;
6775 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6776 int *arg2 = (int *) 0 ;
6777 int *arg3 = (int *) 0 ;
6778 int temp2 ;
6779 int res2 = 0 ;
6780 int temp3 ;
6781 int res3 = 0 ;
6782 PyObject * obj0 = 0 ;
6783 char *kwnames[] = {
6784 (char *) "self", NULL
6785 };
6786
6787 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6788 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6791 if (SWIG_arg_fail(1)) SWIG_fail;
6792 {
6793 PyThreadState* __tstate = wxPyBeginAllowThreads();
6794 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6795
6796 wxPyEndAllowThreads(__tstate);
6797 if (PyErr_Occurred()) SWIG_fail;
6798 }
6799 Py_INCREF(Py_None); resultobj = Py_None;
6800 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6801 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6802 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6803 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6804 return resultobj;
6805 fail:
6806 return NULL;
6807 }
6808
6809
6810 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6811 PyObject *resultobj = NULL;
6812 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6813 double result;
6814 PyObject * obj0 = 0 ;
6815 char *kwnames[] = {
6816 (char *) "self", NULL
6817 };
6818
6819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6821 if (SWIG_arg_fail(1)) SWIG_fail;
6822 {
6823 PyThreadState* __tstate = wxPyBeginAllowThreads();
6824 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6825
6826 wxPyEndAllowThreads(__tstate);
6827 if (PyErr_Occurred()) SWIG_fail;
6828 }
6829 {
6830 resultobj = SWIG_From_double(static_cast<double >(result));
6831 }
6832 return resultobj;
6833 fail:
6834 return NULL;
6835 }
6836
6837
6838 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6839 PyObject *resultobj = NULL;
6840 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6841 double result;
6842 PyObject * obj0 = 0 ;
6843 char *kwnames[] = {
6844 (char *) "self", NULL
6845 };
6846
6847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6849 if (SWIG_arg_fail(1)) SWIG_fail;
6850 {
6851 PyThreadState* __tstate = wxPyBeginAllowThreads();
6852 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6853
6854 wxPyEndAllowThreads(__tstate);
6855 if (PyErr_Occurred()) SWIG_fail;
6856 }
6857 {
6858 resultobj = SWIG_From_double(static_cast<double >(result));
6859 }
6860 return resultobj;
6861 fail:
6862 return NULL;
6863 }
6864
6865
6866 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6867 PyObject *resultobj = NULL;
6868 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6869 double arg2 ;
6870 PyObject * obj0 = 0 ;
6871 PyObject * obj1 = 0 ;
6872 char *kwnames[] = {
6873 (char *) "self",(char *) "length", NULL
6874 };
6875
6876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6878 if (SWIG_arg_fail(1)) SWIG_fail;
6879 {
6880 arg2 = static_cast<double >(SWIG_As_double(obj1));
6881 if (SWIG_arg_fail(2)) SWIG_fail;
6882 }
6883 {
6884 PyThreadState* __tstate = wxPyBeginAllowThreads();
6885 (arg1)->SetVectorLength(arg2);
6886
6887 wxPyEndAllowThreads(__tstate);
6888 if (PyErr_Occurred()) SWIG_fail;
6889 }
6890 Py_INCREF(Py_None); resultobj = Py_None;
6891 return resultobj;
6892 fail:
6893 return NULL;
6894 }
6895
6896
6897 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6898 PyObject *resultobj = NULL;
6899 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6900 double arg2 ;
6901 PyObject * obj0 = 0 ;
6902 PyObject * obj1 = 0 ;
6903 char *kwnames[] = {
6904 (char *) "self",(char *) "degrees", NULL
6905 };
6906
6907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6909 if (SWIG_arg_fail(1)) SWIG_fail;
6910 {
6911 arg2 = static_cast<double >(SWIG_As_double(obj1));
6912 if (SWIG_arg_fail(2)) SWIG_fail;
6913 }
6914 {
6915 PyThreadState* __tstate = wxPyBeginAllowThreads();
6916 (arg1)->SetVectorAngle(arg2);
6917
6918 wxPyEndAllowThreads(__tstate);
6919 if (PyErr_Occurred()) SWIG_fail;
6920 }
6921 Py_INCREF(Py_None); resultobj = Py_None;
6922 return resultobj;
6923 fail:
6924 return NULL;
6925 }
6926
6927
6928 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6929 PyObject *resultobj = NULL;
6930 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6931 wxPoint2D *arg2 = 0 ;
6932 double result;
6933 wxPoint2D temp2 ;
6934 PyObject * obj0 = 0 ;
6935 PyObject * obj1 = 0 ;
6936 char *kwnames[] = {
6937 (char *) "self",(char *) "pt", NULL
6938 };
6939
6940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6942 if (SWIG_arg_fail(1)) SWIG_fail;
6943 {
6944 arg2 = &temp2;
6945 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6946 }
6947 {
6948 PyThreadState* __tstate = wxPyBeginAllowThreads();
6949 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6950
6951 wxPyEndAllowThreads(__tstate);
6952 if (PyErr_Occurred()) SWIG_fail;
6953 }
6954 {
6955 resultobj = SWIG_From_double(static_cast<double >(result));
6956 }
6957 return resultobj;
6958 fail:
6959 return NULL;
6960 }
6961
6962
6963 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6964 PyObject *resultobj = NULL;
6965 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6966 wxPoint2D *arg2 = 0 ;
6967 double result;
6968 wxPoint2D temp2 ;
6969 PyObject * obj0 = 0 ;
6970 PyObject * obj1 = 0 ;
6971 char *kwnames[] = {
6972 (char *) "self",(char *) "pt", NULL
6973 };
6974
6975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6977 if (SWIG_arg_fail(1)) SWIG_fail;
6978 {
6979 arg2 = &temp2;
6980 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6981 }
6982 {
6983 PyThreadState* __tstate = wxPyBeginAllowThreads();
6984 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6985
6986 wxPyEndAllowThreads(__tstate);
6987 if (PyErr_Occurred()) SWIG_fail;
6988 }
6989 {
6990 resultobj = SWIG_From_double(static_cast<double >(result));
6991 }
6992 return resultobj;
6993 fail:
6994 return NULL;
6995 }
6996
6997
6998 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6999 PyObject *resultobj = NULL;
7000 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7001 wxPoint2D *arg2 = 0 ;
7002 double result;
7003 wxPoint2D temp2 ;
7004 PyObject * obj0 = 0 ;
7005 PyObject * obj1 = 0 ;
7006 char *kwnames[] = {
7007 (char *) "self",(char *) "vec", NULL
7008 };
7009
7010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
7011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7012 if (SWIG_arg_fail(1)) SWIG_fail;
7013 {
7014 arg2 = &temp2;
7015 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7016 }
7017 {
7018 PyThreadState* __tstate = wxPyBeginAllowThreads();
7019 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
7020
7021 wxPyEndAllowThreads(__tstate);
7022 if (PyErr_Occurred()) SWIG_fail;
7023 }
7024 {
7025 resultobj = SWIG_From_double(static_cast<double >(result));
7026 }
7027 return resultobj;
7028 fail:
7029 return NULL;
7030 }
7031
7032
7033 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
7034 PyObject *resultobj = NULL;
7035 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7036 wxPoint2D *arg2 = 0 ;
7037 double result;
7038 wxPoint2D temp2 ;
7039 PyObject * obj0 = 0 ;
7040 PyObject * obj1 = 0 ;
7041 char *kwnames[] = {
7042 (char *) "self",(char *) "vec", NULL
7043 };
7044
7045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
7046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7047 if (SWIG_arg_fail(1)) SWIG_fail;
7048 {
7049 arg2 = &temp2;
7050 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7051 }
7052 {
7053 PyThreadState* __tstate = wxPyBeginAllowThreads();
7054 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
7055
7056 wxPyEndAllowThreads(__tstate);
7057 if (PyErr_Occurred()) SWIG_fail;
7058 }
7059 {
7060 resultobj = SWIG_From_double(static_cast<double >(result));
7061 }
7062 return resultobj;
7063 fail:
7064 return NULL;
7065 }
7066
7067
7068 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
7069 PyObject *resultobj = NULL;
7070 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7071 wxPoint2D result;
7072 PyObject * obj0 = 0 ;
7073 char *kwnames[] = {
7074 (char *) "self", NULL
7075 };
7076
7077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
7078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7079 if (SWIG_arg_fail(1)) SWIG_fail;
7080 {
7081 PyThreadState* __tstate = wxPyBeginAllowThreads();
7082 result = (arg1)->operator -();
7083
7084 wxPyEndAllowThreads(__tstate);
7085 if (PyErr_Occurred()) SWIG_fail;
7086 }
7087 {
7088 wxPoint2D * resultptr;
7089 resultptr = new wxPoint2D(static_cast<wxPoint2D & >(result));
7090 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
7091 }
7092 return resultobj;
7093 fail:
7094 return NULL;
7095 }
7096
7097
7098 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
7099 PyObject *resultobj = NULL;
7100 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7101 wxPoint2D *arg2 = 0 ;
7102 wxPoint2D *result;
7103 wxPoint2D temp2 ;
7104 PyObject * obj0 = 0 ;
7105 PyObject * obj1 = 0 ;
7106 char *kwnames[] = {
7107 (char *) "self",(char *) "pt", NULL
7108 };
7109
7110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
7111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7112 if (SWIG_arg_fail(1)) SWIG_fail;
7113 {
7114 arg2 = &temp2;
7115 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7116 }
7117 {
7118 PyThreadState* __tstate = wxPyBeginAllowThreads();
7119 {
7120 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
7121 result = (wxPoint2D *) &_result_ref;
7122 }
7123
7124 wxPyEndAllowThreads(__tstate);
7125 if (PyErr_Occurred()) SWIG_fail;
7126 }
7127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7128 return resultobj;
7129 fail:
7130 return NULL;
7131 }
7132
7133
7134 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
7135 PyObject *resultobj = NULL;
7136 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7137 wxPoint2D *arg2 = 0 ;
7138 wxPoint2D *result;
7139 wxPoint2D temp2 ;
7140 PyObject * obj0 = 0 ;
7141 PyObject * obj1 = 0 ;
7142 char *kwnames[] = {
7143 (char *) "self",(char *) "pt", NULL
7144 };
7145
7146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7148 if (SWIG_arg_fail(1)) SWIG_fail;
7149 {
7150 arg2 = &temp2;
7151 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7152 }
7153 {
7154 PyThreadState* __tstate = wxPyBeginAllowThreads();
7155 {
7156 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7157 result = (wxPoint2D *) &_result_ref;
7158 }
7159
7160 wxPyEndAllowThreads(__tstate);
7161 if (PyErr_Occurred()) SWIG_fail;
7162 }
7163 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7164 return resultobj;
7165 fail:
7166 return NULL;
7167 }
7168
7169
7170 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7171 PyObject *resultobj = NULL;
7172 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7173 wxPoint2D *arg2 = 0 ;
7174 wxPoint2D *result;
7175 wxPoint2D temp2 ;
7176 PyObject * obj0 = 0 ;
7177 PyObject * obj1 = 0 ;
7178 char *kwnames[] = {
7179 (char *) "self",(char *) "pt", NULL
7180 };
7181
7182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7184 if (SWIG_arg_fail(1)) SWIG_fail;
7185 {
7186 arg2 = &temp2;
7187 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7188 }
7189 {
7190 PyThreadState* __tstate = wxPyBeginAllowThreads();
7191 {
7192 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7193 result = (wxPoint2D *) &_result_ref;
7194 }
7195
7196 wxPyEndAllowThreads(__tstate);
7197 if (PyErr_Occurred()) SWIG_fail;
7198 }
7199 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7200 return resultobj;
7201 fail:
7202 return NULL;
7203 }
7204
7205
7206 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7207 PyObject *resultobj = NULL;
7208 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7209 wxPoint2D *arg2 = 0 ;
7210 wxPoint2D *result;
7211 wxPoint2D temp2 ;
7212 PyObject * obj0 = 0 ;
7213 PyObject * obj1 = 0 ;
7214 char *kwnames[] = {
7215 (char *) "self",(char *) "pt", NULL
7216 };
7217
7218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7220 if (SWIG_arg_fail(1)) SWIG_fail;
7221 {
7222 arg2 = &temp2;
7223 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7224 }
7225 {
7226 PyThreadState* __tstate = wxPyBeginAllowThreads();
7227 {
7228 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7229 result = (wxPoint2D *) &_result_ref;
7230 }
7231
7232 wxPyEndAllowThreads(__tstate);
7233 if (PyErr_Occurred()) SWIG_fail;
7234 }
7235 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7236 return resultobj;
7237 fail:
7238 return NULL;
7239 }
7240
7241
7242 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7243 PyObject *resultobj = NULL;
7244 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7245 wxPoint2D *arg2 = 0 ;
7246 bool result;
7247 wxPoint2D temp2 ;
7248 PyObject * obj0 = 0 ;
7249 PyObject * obj1 = 0 ;
7250 char *kwnames[] = {
7251 (char *) "self",(char *) "pt", NULL
7252 };
7253
7254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7256 if (SWIG_arg_fail(1)) SWIG_fail;
7257 {
7258 arg2 = &temp2;
7259 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7260 }
7261 {
7262 PyThreadState* __tstate = wxPyBeginAllowThreads();
7263 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7264
7265 wxPyEndAllowThreads(__tstate);
7266 if (PyErr_Occurred()) SWIG_fail;
7267 }
7268 {
7269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7270 }
7271 return resultobj;
7272 fail:
7273 return NULL;
7274 }
7275
7276
7277 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7278 PyObject *resultobj = NULL;
7279 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7280 wxPoint2D *arg2 = 0 ;
7281 bool result;
7282 wxPoint2D temp2 ;
7283 PyObject * obj0 = 0 ;
7284 PyObject * obj1 = 0 ;
7285 char *kwnames[] = {
7286 (char *) "self",(char *) "pt", NULL
7287 };
7288
7289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7291 if (SWIG_arg_fail(1)) SWIG_fail;
7292 {
7293 arg2 = &temp2;
7294 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7295 }
7296 {
7297 PyThreadState* __tstate = wxPyBeginAllowThreads();
7298 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7299
7300 wxPyEndAllowThreads(__tstate);
7301 if (PyErr_Occurred()) SWIG_fail;
7302 }
7303 {
7304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7305 }
7306 return resultobj;
7307 fail:
7308 return NULL;
7309 }
7310
7311
7312 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7313 PyObject *resultobj = NULL;
7314 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7315 double arg2 ;
7316 PyObject * obj0 = 0 ;
7317 PyObject * obj1 = 0 ;
7318 char *kwnames[] = {
7319 (char *) "self",(char *) "m_x", NULL
7320 };
7321
7322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7324 if (SWIG_arg_fail(1)) SWIG_fail;
7325 {
7326 arg2 = static_cast<double >(SWIG_As_double(obj1));
7327 if (SWIG_arg_fail(2)) SWIG_fail;
7328 }
7329 if (arg1) (arg1)->m_x = arg2;
7330
7331 Py_INCREF(Py_None); resultobj = Py_None;
7332 return resultobj;
7333 fail:
7334 return NULL;
7335 }
7336
7337
7338 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7339 PyObject *resultobj = NULL;
7340 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7341 double result;
7342 PyObject * obj0 = 0 ;
7343 char *kwnames[] = {
7344 (char *) "self", NULL
7345 };
7346
7347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7349 if (SWIG_arg_fail(1)) SWIG_fail;
7350 result = (double) ((arg1)->m_x);
7351
7352 {
7353 resultobj = SWIG_From_double(static_cast<double >(result));
7354 }
7355 return resultobj;
7356 fail:
7357 return NULL;
7358 }
7359
7360
7361 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7362 PyObject *resultobj = NULL;
7363 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7364 double arg2 ;
7365 PyObject * obj0 = 0 ;
7366 PyObject * obj1 = 0 ;
7367 char *kwnames[] = {
7368 (char *) "self",(char *) "m_y", NULL
7369 };
7370
7371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7373 if (SWIG_arg_fail(1)) SWIG_fail;
7374 {
7375 arg2 = static_cast<double >(SWIG_As_double(obj1));
7376 if (SWIG_arg_fail(2)) SWIG_fail;
7377 }
7378 if (arg1) (arg1)->m_y = arg2;
7379
7380 Py_INCREF(Py_None); resultobj = Py_None;
7381 return resultobj;
7382 fail:
7383 return NULL;
7384 }
7385
7386
7387 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7388 PyObject *resultobj = NULL;
7389 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7390 double result;
7391 PyObject * obj0 = 0 ;
7392 char *kwnames[] = {
7393 (char *) "self", NULL
7394 };
7395
7396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7398 if (SWIG_arg_fail(1)) SWIG_fail;
7399 result = (double) ((arg1)->m_y);
7400
7401 {
7402 resultobj = SWIG_From_double(static_cast<double >(result));
7403 }
7404 return resultobj;
7405 fail:
7406 return NULL;
7407 }
7408
7409
7410 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7411 PyObject *resultobj = NULL;
7412 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7413 double arg2 = (double) 0 ;
7414 double arg3 = (double) 0 ;
7415 PyObject * obj0 = 0 ;
7416 PyObject * obj1 = 0 ;
7417 PyObject * obj2 = 0 ;
7418 char *kwnames[] = {
7419 (char *) "self",(char *) "x",(char *) "y", NULL
7420 };
7421
7422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7424 if (SWIG_arg_fail(1)) SWIG_fail;
7425 if (obj1) {
7426 {
7427 arg2 = static_cast<double >(SWIG_As_double(obj1));
7428 if (SWIG_arg_fail(2)) SWIG_fail;
7429 }
7430 }
7431 if (obj2) {
7432 {
7433 arg3 = static_cast<double >(SWIG_As_double(obj2));
7434 if (SWIG_arg_fail(3)) SWIG_fail;
7435 }
7436 }
7437 {
7438 PyThreadState* __tstate = wxPyBeginAllowThreads();
7439 wxPoint2D_Set(arg1,arg2,arg3);
7440
7441 wxPyEndAllowThreads(__tstate);
7442 if (PyErr_Occurred()) SWIG_fail;
7443 }
7444 Py_INCREF(Py_None); resultobj = Py_None;
7445 return resultobj;
7446 fail:
7447 return NULL;
7448 }
7449
7450
7451 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7452 PyObject *resultobj = NULL;
7453 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7454 PyObject *result;
7455 PyObject * obj0 = 0 ;
7456 char *kwnames[] = {
7457 (char *) "self", NULL
7458 };
7459
7460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7462 if (SWIG_arg_fail(1)) SWIG_fail;
7463 {
7464 PyThreadState* __tstate = wxPyBeginAllowThreads();
7465 result = (PyObject *)wxPoint2D_Get(arg1);
7466
7467 wxPyEndAllowThreads(__tstate);
7468 if (PyErr_Occurred()) SWIG_fail;
7469 }
7470 resultobj = result;
7471 return resultobj;
7472 fail:
7473 return NULL;
7474 }
7475
7476
7477 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7478 PyObject *obj;
7479 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7480 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7481 Py_INCREF(obj);
7482 return Py_BuildValue((char *)"");
7483 }
7484 static int _wrap_DefaultPosition_set(PyObject *) {
7485 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7486 return 1;
7487 }
7488
7489
7490 static PyObject *_wrap_DefaultPosition_get(void) {
7491 PyObject *pyobj = NULL;
7492
7493 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7494 return pyobj;
7495 }
7496
7497
7498 static int _wrap_DefaultSize_set(PyObject *) {
7499 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7500 return 1;
7501 }
7502
7503
7504 static PyObject *_wrap_DefaultSize_get(void) {
7505 PyObject *pyobj = NULL;
7506
7507 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7508 return pyobj;
7509 }
7510
7511
7512 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7513 PyObject *resultobj = NULL;
7514 PyObject *arg1 = (PyObject *) 0 ;
7515 wxPyInputStream *result;
7516 PyObject * obj0 = 0 ;
7517 char *kwnames[] = {
7518 (char *) "p", NULL
7519 };
7520
7521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7522 arg1 = obj0;
7523 {
7524 PyThreadState* __tstate = wxPyBeginAllowThreads();
7525 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7526
7527 wxPyEndAllowThreads(__tstate);
7528 if (PyErr_Occurred()) SWIG_fail;
7529 }
7530 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7531 return resultobj;
7532 fail:
7533 return NULL;
7534 }
7535
7536
7537 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7538 PyObject *resultobj = NULL;
7539 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7540 PyObject * obj0 = 0 ;
7541 char *kwnames[] = {
7542 (char *) "self", NULL
7543 };
7544
7545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7547 if (SWIG_arg_fail(1)) SWIG_fail;
7548 {
7549 PyThreadState* __tstate = wxPyBeginAllowThreads();
7550 delete arg1;
7551
7552 wxPyEndAllowThreads(__tstate);
7553 if (PyErr_Occurred()) SWIG_fail;
7554 }
7555 Py_INCREF(Py_None); resultobj = Py_None;
7556 return resultobj;
7557 fail:
7558 return NULL;
7559 }
7560
7561
7562 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7563 PyObject *resultobj = NULL;
7564 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7565 PyObject * obj0 = 0 ;
7566 char *kwnames[] = {
7567 (char *) "self", NULL
7568 };
7569
7570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7572 if (SWIG_arg_fail(1)) SWIG_fail;
7573 {
7574 PyThreadState* __tstate = wxPyBeginAllowThreads();
7575 (arg1)->close();
7576
7577 wxPyEndAllowThreads(__tstate);
7578 if (PyErr_Occurred()) SWIG_fail;
7579 }
7580 Py_INCREF(Py_None); resultobj = Py_None;
7581 return resultobj;
7582 fail:
7583 return NULL;
7584 }
7585
7586
7587 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7588 PyObject *resultobj = NULL;
7589 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7590 PyObject * obj0 = 0 ;
7591 char *kwnames[] = {
7592 (char *) "self", NULL
7593 };
7594
7595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7597 if (SWIG_arg_fail(1)) SWIG_fail;
7598 {
7599 PyThreadState* __tstate = wxPyBeginAllowThreads();
7600 (arg1)->flush();
7601
7602 wxPyEndAllowThreads(__tstate);
7603 if (PyErr_Occurred()) SWIG_fail;
7604 }
7605 Py_INCREF(Py_None); resultobj = Py_None;
7606 return resultobj;
7607 fail:
7608 return NULL;
7609 }
7610
7611
7612 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7613 PyObject *resultobj = NULL;
7614 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7615 bool result;
7616 PyObject * obj0 = 0 ;
7617 char *kwnames[] = {
7618 (char *) "self", NULL
7619 };
7620
7621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7623 if (SWIG_arg_fail(1)) SWIG_fail;
7624 {
7625 PyThreadState* __tstate = wxPyBeginAllowThreads();
7626 result = (bool)(arg1)->eof();
7627
7628 wxPyEndAllowThreads(__tstate);
7629 if (PyErr_Occurred()) SWIG_fail;
7630 }
7631 {
7632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7633 }
7634 return resultobj;
7635 fail:
7636 return NULL;
7637 }
7638
7639
7640 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7641 PyObject *resultobj = NULL;
7642 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7643 int arg2 = (int) -1 ;
7644 PyObject *result;
7645 PyObject * obj0 = 0 ;
7646 PyObject * obj1 = 0 ;
7647 char *kwnames[] = {
7648 (char *) "self",(char *) "size", NULL
7649 };
7650
7651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7653 if (SWIG_arg_fail(1)) SWIG_fail;
7654 if (obj1) {
7655 {
7656 arg2 = static_cast<int >(SWIG_As_int(obj1));
7657 if (SWIG_arg_fail(2)) SWIG_fail;
7658 }
7659 }
7660 {
7661 PyThreadState* __tstate = wxPyBeginAllowThreads();
7662 result = (PyObject *)(arg1)->read(arg2);
7663
7664 wxPyEndAllowThreads(__tstate);
7665 if (PyErr_Occurred()) SWIG_fail;
7666 }
7667 resultobj = result;
7668 return resultobj;
7669 fail:
7670 return NULL;
7671 }
7672
7673
7674 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7675 PyObject *resultobj = NULL;
7676 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7677 int arg2 = (int) -1 ;
7678 PyObject *result;
7679 PyObject * obj0 = 0 ;
7680 PyObject * obj1 = 0 ;
7681 char *kwnames[] = {
7682 (char *) "self",(char *) "size", NULL
7683 };
7684
7685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7687 if (SWIG_arg_fail(1)) SWIG_fail;
7688 if (obj1) {
7689 {
7690 arg2 = static_cast<int >(SWIG_As_int(obj1));
7691 if (SWIG_arg_fail(2)) SWIG_fail;
7692 }
7693 }
7694 {
7695 PyThreadState* __tstate = wxPyBeginAllowThreads();
7696 result = (PyObject *)(arg1)->readline(arg2);
7697
7698 wxPyEndAllowThreads(__tstate);
7699 if (PyErr_Occurred()) SWIG_fail;
7700 }
7701 resultobj = result;
7702 return resultobj;
7703 fail:
7704 return NULL;
7705 }
7706
7707
7708 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7709 PyObject *resultobj = NULL;
7710 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7711 int arg2 = (int) -1 ;
7712 PyObject *result;
7713 PyObject * obj0 = 0 ;
7714 PyObject * obj1 = 0 ;
7715 char *kwnames[] = {
7716 (char *) "self",(char *) "sizehint", NULL
7717 };
7718
7719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7721 if (SWIG_arg_fail(1)) SWIG_fail;
7722 if (obj1) {
7723 {
7724 arg2 = static_cast<int >(SWIG_As_int(obj1));
7725 if (SWIG_arg_fail(2)) SWIG_fail;
7726 }
7727 }
7728 {
7729 PyThreadState* __tstate = wxPyBeginAllowThreads();
7730 result = (PyObject *)(arg1)->readlines(arg2);
7731
7732 wxPyEndAllowThreads(__tstate);
7733 if (PyErr_Occurred()) SWIG_fail;
7734 }
7735 resultobj = result;
7736 return resultobj;
7737 fail:
7738 return NULL;
7739 }
7740
7741
7742 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7743 PyObject *resultobj = NULL;
7744 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7745 int arg2 ;
7746 int arg3 = (int) 0 ;
7747 PyObject * obj0 = 0 ;
7748 PyObject * obj1 = 0 ;
7749 PyObject * obj2 = 0 ;
7750 char *kwnames[] = {
7751 (char *) "self",(char *) "offset",(char *) "whence", NULL
7752 };
7753
7754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7756 if (SWIG_arg_fail(1)) SWIG_fail;
7757 {
7758 arg2 = static_cast<int >(SWIG_As_int(obj1));
7759 if (SWIG_arg_fail(2)) SWIG_fail;
7760 }
7761 if (obj2) {
7762 {
7763 arg3 = static_cast<int >(SWIG_As_int(obj2));
7764 if (SWIG_arg_fail(3)) SWIG_fail;
7765 }
7766 }
7767 {
7768 PyThreadState* __tstate = wxPyBeginAllowThreads();
7769 (arg1)->seek(arg2,arg3);
7770
7771 wxPyEndAllowThreads(__tstate);
7772 if (PyErr_Occurred()) SWIG_fail;
7773 }
7774 Py_INCREF(Py_None); resultobj = Py_None;
7775 return resultobj;
7776 fail:
7777 return NULL;
7778 }
7779
7780
7781 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7782 PyObject *resultobj = NULL;
7783 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7784 int result;
7785 PyObject * obj0 = 0 ;
7786 char *kwnames[] = {
7787 (char *) "self", NULL
7788 };
7789
7790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7792 if (SWIG_arg_fail(1)) SWIG_fail;
7793 {
7794 PyThreadState* __tstate = wxPyBeginAllowThreads();
7795 result = (int)(arg1)->tell();
7796
7797 wxPyEndAllowThreads(__tstate);
7798 if (PyErr_Occurred()) SWIG_fail;
7799 }
7800 {
7801 resultobj = SWIG_From_int(static_cast<int >(result));
7802 }
7803 return resultobj;
7804 fail:
7805 return NULL;
7806 }
7807
7808
7809 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7810 PyObject *resultobj = NULL;
7811 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7812 char result;
7813 PyObject * obj0 = 0 ;
7814 char *kwnames[] = {
7815 (char *) "self", NULL
7816 };
7817
7818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7820 if (SWIG_arg_fail(1)) SWIG_fail;
7821 {
7822 PyThreadState* __tstate = wxPyBeginAllowThreads();
7823 result = (char)(arg1)->Peek();
7824
7825 wxPyEndAllowThreads(__tstate);
7826 if (PyErr_Occurred()) SWIG_fail;
7827 }
7828 {
7829 resultobj = SWIG_From_char(static_cast<char >(result));
7830 }
7831 return resultobj;
7832 fail:
7833 return NULL;
7834 }
7835
7836
7837 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7838 PyObject *resultobj = NULL;
7839 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7840 char result;
7841 PyObject * obj0 = 0 ;
7842 char *kwnames[] = {
7843 (char *) "self", NULL
7844 };
7845
7846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7848 if (SWIG_arg_fail(1)) SWIG_fail;
7849 {
7850 PyThreadState* __tstate = wxPyBeginAllowThreads();
7851 result = (char)(arg1)->GetC();
7852
7853 wxPyEndAllowThreads(__tstate);
7854 if (PyErr_Occurred()) SWIG_fail;
7855 }
7856 {
7857 resultobj = SWIG_From_char(static_cast<char >(result));
7858 }
7859 return resultobj;
7860 fail:
7861 return NULL;
7862 }
7863
7864
7865 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7866 PyObject *resultobj = NULL;
7867 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7868 size_t result;
7869 PyObject * obj0 = 0 ;
7870 char *kwnames[] = {
7871 (char *) "self", NULL
7872 };
7873
7874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7876 if (SWIG_arg_fail(1)) SWIG_fail;
7877 {
7878 PyThreadState* __tstate = wxPyBeginAllowThreads();
7879 result = (size_t)(arg1)->LastRead();
7880
7881 wxPyEndAllowThreads(__tstate);
7882 if (PyErr_Occurred()) SWIG_fail;
7883 }
7884 {
7885 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
7886 }
7887 return resultobj;
7888 fail:
7889 return NULL;
7890 }
7891
7892
7893 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7894 PyObject *resultobj = NULL;
7895 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7896 bool result;
7897 PyObject * obj0 = 0 ;
7898 char *kwnames[] = {
7899 (char *) "self", NULL
7900 };
7901
7902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7904 if (SWIG_arg_fail(1)) SWIG_fail;
7905 {
7906 PyThreadState* __tstate = wxPyBeginAllowThreads();
7907 result = (bool)(arg1)->CanRead();
7908
7909 wxPyEndAllowThreads(__tstate);
7910 if (PyErr_Occurred()) SWIG_fail;
7911 }
7912 {
7913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7914 }
7915 return resultobj;
7916 fail:
7917 return NULL;
7918 }
7919
7920
7921 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7922 PyObject *resultobj = NULL;
7923 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7924 bool result;
7925 PyObject * obj0 = 0 ;
7926 char *kwnames[] = {
7927 (char *) "self", NULL
7928 };
7929
7930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7932 if (SWIG_arg_fail(1)) SWIG_fail;
7933 {
7934 PyThreadState* __tstate = wxPyBeginAllowThreads();
7935 result = (bool)(arg1)->Eof();
7936
7937 wxPyEndAllowThreads(__tstate);
7938 if (PyErr_Occurred()) SWIG_fail;
7939 }
7940 {
7941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7942 }
7943 return resultobj;
7944 fail:
7945 return NULL;
7946 }
7947
7948
7949 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7950 PyObject *resultobj = NULL;
7951 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7952 char arg2 ;
7953 bool result;
7954 PyObject * obj0 = 0 ;
7955 PyObject * obj1 = 0 ;
7956 char *kwnames[] = {
7957 (char *) "self",(char *) "c", NULL
7958 };
7959
7960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7962 if (SWIG_arg_fail(1)) SWIG_fail;
7963 {
7964 arg2 = static_cast<char >(SWIG_As_char(obj1));
7965 if (SWIG_arg_fail(2)) SWIG_fail;
7966 }
7967 {
7968 PyThreadState* __tstate = wxPyBeginAllowThreads();
7969 result = (bool)(arg1)->Ungetch(arg2);
7970
7971 wxPyEndAllowThreads(__tstate);
7972 if (PyErr_Occurred()) SWIG_fail;
7973 }
7974 {
7975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7976 }
7977 return resultobj;
7978 fail:
7979 return NULL;
7980 }
7981
7982
7983 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7984 PyObject *resultobj = NULL;
7985 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7986 long arg2 ;
7987 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7988 long result;
7989 PyObject * obj0 = 0 ;
7990 PyObject * obj1 = 0 ;
7991 PyObject * obj2 = 0 ;
7992 char *kwnames[] = {
7993 (char *) "self",(char *) "pos",(char *) "mode", NULL
7994 };
7995
7996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7998 if (SWIG_arg_fail(1)) SWIG_fail;
7999 {
8000 arg2 = static_cast<long >(SWIG_As_long(obj1));
8001 if (SWIG_arg_fail(2)) SWIG_fail;
8002 }
8003 if (obj2) {
8004 {
8005 arg3 = static_cast<wxSeekMode >(SWIG_As_int(obj2));
8006 if (SWIG_arg_fail(3)) SWIG_fail;
8007 }
8008 }
8009 {
8010 PyThreadState* __tstate = wxPyBeginAllowThreads();
8011 result = (long)(arg1)->SeekI(arg2,arg3);
8012
8013 wxPyEndAllowThreads(__tstate);
8014 if (PyErr_Occurred()) SWIG_fail;
8015 }
8016 {
8017 resultobj = SWIG_From_long(static_cast<long >(result));
8018 }
8019 return resultobj;
8020 fail:
8021 return NULL;
8022 }
8023
8024
8025 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
8026 PyObject *resultobj = NULL;
8027 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8028 long result;
8029 PyObject * obj0 = 0 ;
8030 char *kwnames[] = {
8031 (char *) "self", NULL
8032 };
8033
8034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
8035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
8036 if (SWIG_arg_fail(1)) SWIG_fail;
8037 {
8038 PyThreadState* __tstate = wxPyBeginAllowThreads();
8039 result = (long)(arg1)->TellI();
8040
8041 wxPyEndAllowThreads(__tstate);
8042 if (PyErr_Occurred()) SWIG_fail;
8043 }
8044 {
8045 resultobj = SWIG_From_long(static_cast<long >(result));
8046 }
8047 return resultobj;
8048 fail:
8049 return NULL;
8050 }
8051
8052
8053 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
8054 PyObject *obj;
8055 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8056 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
8057 Py_INCREF(obj);
8058 return Py_BuildValue((char *)"");
8059 }
8060 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
8061 PyObject *resultobj = NULL;
8062 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
8063 PyObject *arg2 = (PyObject *) 0 ;
8064 PyObject * obj0 = 0 ;
8065 PyObject * obj1 = 0 ;
8066 char *kwnames[] = {
8067 (char *) "self",(char *) "obj", NULL
8068 };
8069
8070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
8071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
8072 if (SWIG_arg_fail(1)) SWIG_fail;
8073 arg2 = obj1;
8074 {
8075 PyThreadState* __tstate = wxPyBeginAllowThreads();
8076 wxOutputStream_write(arg1,arg2);
8077
8078 wxPyEndAllowThreads(__tstate);
8079 if (PyErr_Occurred()) SWIG_fail;
8080 }
8081 Py_INCREF(Py_None); resultobj = Py_None;
8082 return resultobj;
8083 fail:
8084 return NULL;
8085 }
8086
8087
8088 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
8089 PyObject *obj;
8090 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8091 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
8092 Py_INCREF(obj);
8093 return Py_BuildValue((char *)"");
8094 }
8095 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8096 PyObject *resultobj = NULL;
8097 wxInputStream *arg1 = (wxInputStream *) 0 ;
8098 wxString *arg2 = 0 ;
8099 wxString *arg3 = 0 ;
8100 wxString *arg4 = 0 ;
8101 wxDateTime arg5 ;
8102 wxFSFile *result;
8103 wxPyInputStream *temp1 ;
8104 bool temp2 = false ;
8105 bool temp3 = false ;
8106 bool temp4 = false ;
8107 PyObject * obj0 = 0 ;
8108 PyObject * obj1 = 0 ;
8109 PyObject * obj2 = 0 ;
8110 PyObject * obj3 = 0 ;
8111 PyObject * obj4 = 0 ;
8112 char *kwnames[] = {
8113 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
8114 };
8115
8116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
8117 {
8118 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
8119 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
8120 } else {
8121 PyErr_Clear(); // clear the failure of the wxPyConvert above
8122 arg1 = wxPyCBInputStream_create(obj0, true);
8123 if (arg1 == NULL) {
8124 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
8125 SWIG_fail;
8126 }
8127 }
8128 }
8129 {
8130 arg2 = wxString_in_helper(obj1);
8131 if (arg2 == NULL) SWIG_fail;
8132 temp2 = true;
8133 }
8134 {
8135 arg3 = wxString_in_helper(obj2);
8136 if (arg3 == NULL) SWIG_fail;
8137 temp3 = true;
8138 }
8139 {
8140 arg4 = wxString_in_helper(obj3);
8141 if (arg4 == NULL) SWIG_fail;
8142 temp4 = true;
8143 }
8144 {
8145 wxDateTime * argp;
8146 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8147 if (SWIG_arg_fail(5)) SWIG_fail;
8148 if (argp == NULL) {
8149 SWIG_null_ref("wxDateTime");
8150 }
8151 if (SWIG_arg_fail(5)) SWIG_fail;
8152 arg5 = *argp;
8153 }
8154 {
8155 PyThreadState* __tstate = wxPyBeginAllowThreads();
8156 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8157
8158 wxPyEndAllowThreads(__tstate);
8159 if (PyErr_Occurred()) SWIG_fail;
8160 }
8161 {
8162 resultobj = wxPyMake_wxObject(result, 1);
8163 }
8164 {
8165 if (temp2)
8166 delete arg2;
8167 }
8168 {
8169 if (temp3)
8170 delete arg3;
8171 }
8172 {
8173 if (temp4)
8174 delete arg4;
8175 }
8176 return resultobj;
8177 fail:
8178 {
8179 if (temp2)
8180 delete arg2;
8181 }
8182 {
8183 if (temp3)
8184 delete arg3;
8185 }
8186 {
8187 if (temp4)
8188 delete arg4;
8189 }
8190 return NULL;
8191 }
8192
8193
8194 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8195 PyObject *resultobj = NULL;
8196 wxFSFile *arg1 = (wxFSFile *) 0 ;
8197 PyObject * obj0 = 0 ;
8198 char *kwnames[] = {
8199 (char *) "self", NULL
8200 };
8201
8202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8204 if (SWIG_arg_fail(1)) SWIG_fail;
8205 {
8206 PyThreadState* __tstate = wxPyBeginAllowThreads();
8207 delete arg1;
8208
8209 wxPyEndAllowThreads(__tstate);
8210 if (PyErr_Occurred()) SWIG_fail;
8211 }
8212 Py_INCREF(Py_None); resultobj = Py_None;
8213 return resultobj;
8214 fail:
8215 return NULL;
8216 }
8217
8218
8219 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8220 PyObject *resultobj = NULL;
8221 wxFSFile *arg1 = (wxFSFile *) 0 ;
8222 wxInputStream *result;
8223 PyObject * obj0 = 0 ;
8224 char *kwnames[] = {
8225 (char *) "self", NULL
8226 };
8227
8228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8230 if (SWIG_arg_fail(1)) SWIG_fail;
8231 {
8232 PyThreadState* __tstate = wxPyBeginAllowThreads();
8233 result = (wxInputStream *)(arg1)->GetStream();
8234
8235 wxPyEndAllowThreads(__tstate);
8236 if (PyErr_Occurred()) SWIG_fail;
8237 }
8238 {
8239 wxPyInputStream * _ptr = NULL;
8240
8241 if (result) {
8242 _ptr = new wxPyInputStream(result);
8243 }
8244 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8245 }
8246 return resultobj;
8247 fail:
8248 return NULL;
8249 }
8250
8251
8252 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8253 PyObject *resultobj = NULL;
8254 wxFSFile *arg1 = (wxFSFile *) 0 ;
8255 wxString *result;
8256 PyObject * obj0 = 0 ;
8257 char *kwnames[] = {
8258 (char *) "self", NULL
8259 };
8260
8261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8263 if (SWIG_arg_fail(1)) SWIG_fail;
8264 {
8265 PyThreadState* __tstate = wxPyBeginAllowThreads();
8266 {
8267 wxString const &_result_ref = (arg1)->GetMimeType();
8268 result = (wxString *) &_result_ref;
8269 }
8270
8271 wxPyEndAllowThreads(__tstate);
8272 if (PyErr_Occurred()) SWIG_fail;
8273 }
8274 {
8275 #if wxUSE_UNICODE
8276 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8277 #else
8278 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8279 #endif
8280 }
8281 return resultobj;
8282 fail:
8283 return NULL;
8284 }
8285
8286
8287 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8288 PyObject *resultobj = NULL;
8289 wxFSFile *arg1 = (wxFSFile *) 0 ;
8290 wxString *result;
8291 PyObject * obj0 = 0 ;
8292 char *kwnames[] = {
8293 (char *) "self", NULL
8294 };
8295
8296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8298 if (SWIG_arg_fail(1)) SWIG_fail;
8299 {
8300 PyThreadState* __tstate = wxPyBeginAllowThreads();
8301 {
8302 wxString const &_result_ref = (arg1)->GetLocation();
8303 result = (wxString *) &_result_ref;
8304 }
8305
8306 wxPyEndAllowThreads(__tstate);
8307 if (PyErr_Occurred()) SWIG_fail;
8308 }
8309 {
8310 #if wxUSE_UNICODE
8311 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8312 #else
8313 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8314 #endif
8315 }
8316 return resultobj;
8317 fail:
8318 return NULL;
8319 }
8320
8321
8322 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8323 PyObject *resultobj = NULL;
8324 wxFSFile *arg1 = (wxFSFile *) 0 ;
8325 wxString *result;
8326 PyObject * obj0 = 0 ;
8327 char *kwnames[] = {
8328 (char *) "self", NULL
8329 };
8330
8331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8333 if (SWIG_arg_fail(1)) SWIG_fail;
8334 {
8335 PyThreadState* __tstate = wxPyBeginAllowThreads();
8336 {
8337 wxString const &_result_ref = (arg1)->GetAnchor();
8338 result = (wxString *) &_result_ref;
8339 }
8340
8341 wxPyEndAllowThreads(__tstate);
8342 if (PyErr_Occurred()) SWIG_fail;
8343 }
8344 {
8345 #if wxUSE_UNICODE
8346 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8347 #else
8348 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8349 #endif
8350 }
8351 return resultobj;
8352 fail:
8353 return NULL;
8354 }
8355
8356
8357 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8358 PyObject *resultobj = NULL;
8359 wxFSFile *arg1 = (wxFSFile *) 0 ;
8360 wxDateTime result;
8361 PyObject * obj0 = 0 ;
8362 char *kwnames[] = {
8363 (char *) "self", NULL
8364 };
8365
8366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8368 if (SWIG_arg_fail(1)) SWIG_fail;
8369 {
8370 PyThreadState* __tstate = wxPyBeginAllowThreads();
8371 result = (arg1)->GetModificationTime();
8372
8373 wxPyEndAllowThreads(__tstate);
8374 if (PyErr_Occurred()) SWIG_fail;
8375 }
8376 {
8377 wxDateTime * resultptr;
8378 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
8379 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8380 }
8381 return resultobj;
8382 fail:
8383 return NULL;
8384 }
8385
8386
8387 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8388 PyObject *obj;
8389 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8390 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8391 Py_INCREF(obj);
8392 return Py_BuildValue((char *)"");
8393 }
8394 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8395 PyObject *obj;
8396 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8397 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8398 Py_INCREF(obj);
8399 return Py_BuildValue((char *)"");
8400 }
8401 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8402 PyObject *resultobj = NULL;
8403 wxPyFileSystemHandler *result;
8404 char *kwnames[] = {
8405 NULL
8406 };
8407
8408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8409 {
8410 PyThreadState* __tstate = wxPyBeginAllowThreads();
8411 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8412
8413 wxPyEndAllowThreads(__tstate);
8414 if (PyErr_Occurred()) SWIG_fail;
8415 }
8416 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8417 return resultobj;
8418 fail:
8419 return NULL;
8420 }
8421
8422
8423 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8424 PyObject *resultobj = NULL;
8425 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8426 PyObject *arg2 = (PyObject *) 0 ;
8427 PyObject *arg3 = (PyObject *) 0 ;
8428 PyObject * obj0 = 0 ;
8429 PyObject * obj1 = 0 ;
8430 PyObject * obj2 = 0 ;
8431 char *kwnames[] = {
8432 (char *) "self",(char *) "self",(char *) "_class", NULL
8433 };
8434
8435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8437 if (SWIG_arg_fail(1)) SWIG_fail;
8438 arg2 = obj1;
8439 arg3 = obj2;
8440 {
8441 PyThreadState* __tstate = wxPyBeginAllowThreads();
8442 (arg1)->_setCallbackInfo(arg2,arg3);
8443
8444 wxPyEndAllowThreads(__tstate);
8445 if (PyErr_Occurred()) SWIG_fail;
8446 }
8447 Py_INCREF(Py_None); resultobj = Py_None;
8448 return resultobj;
8449 fail:
8450 return NULL;
8451 }
8452
8453
8454 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8455 PyObject *resultobj = NULL;
8456 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8457 wxString *arg2 = 0 ;
8458 bool result;
8459 bool temp2 = false ;
8460 PyObject * obj0 = 0 ;
8461 PyObject * obj1 = 0 ;
8462 char *kwnames[] = {
8463 (char *) "self",(char *) "location", NULL
8464 };
8465
8466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8468 if (SWIG_arg_fail(1)) SWIG_fail;
8469 {
8470 arg2 = wxString_in_helper(obj1);
8471 if (arg2 == NULL) SWIG_fail;
8472 temp2 = true;
8473 }
8474 {
8475 PyThreadState* __tstate = wxPyBeginAllowThreads();
8476 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8477
8478 wxPyEndAllowThreads(__tstate);
8479 if (PyErr_Occurred()) SWIG_fail;
8480 }
8481 {
8482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8483 }
8484 {
8485 if (temp2)
8486 delete arg2;
8487 }
8488 return resultobj;
8489 fail:
8490 {
8491 if (temp2)
8492 delete arg2;
8493 }
8494 return NULL;
8495 }
8496
8497
8498 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8499 PyObject *resultobj = NULL;
8500 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8501 wxFileSystem *arg2 = 0 ;
8502 wxString *arg3 = 0 ;
8503 wxFSFile *result;
8504 bool temp3 = false ;
8505 PyObject * obj0 = 0 ;
8506 PyObject * obj1 = 0 ;
8507 PyObject * obj2 = 0 ;
8508 char *kwnames[] = {
8509 (char *) "self",(char *) "fs",(char *) "location", NULL
8510 };
8511
8512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8514 if (SWIG_arg_fail(1)) SWIG_fail;
8515 {
8516 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8517 if (SWIG_arg_fail(2)) SWIG_fail;
8518 if (arg2 == NULL) {
8519 SWIG_null_ref("wxFileSystem");
8520 }
8521 if (SWIG_arg_fail(2)) SWIG_fail;
8522 }
8523 {
8524 arg3 = wxString_in_helper(obj2);
8525 if (arg3 == NULL) SWIG_fail;
8526 temp3 = true;
8527 }
8528 {
8529 PyThreadState* __tstate = wxPyBeginAllowThreads();
8530 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8531
8532 wxPyEndAllowThreads(__tstate);
8533 if (PyErr_Occurred()) SWIG_fail;
8534 }
8535 {
8536 resultobj = wxPyMake_wxObject(result, 1);
8537 }
8538 {
8539 if (temp3)
8540 delete arg3;
8541 }
8542 return resultobj;
8543 fail:
8544 {
8545 if (temp3)
8546 delete arg3;
8547 }
8548 return NULL;
8549 }
8550
8551
8552 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8553 PyObject *resultobj = NULL;
8554 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8555 wxString *arg2 = 0 ;
8556 int arg3 = (int) 0 ;
8557 wxString result;
8558 bool temp2 = false ;
8559 PyObject * obj0 = 0 ;
8560 PyObject * obj1 = 0 ;
8561 PyObject * obj2 = 0 ;
8562 char *kwnames[] = {
8563 (char *) "self",(char *) "spec",(char *) "flags", NULL
8564 };
8565
8566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8568 if (SWIG_arg_fail(1)) SWIG_fail;
8569 {
8570 arg2 = wxString_in_helper(obj1);
8571 if (arg2 == NULL) SWIG_fail;
8572 temp2 = true;
8573 }
8574 if (obj2) {
8575 {
8576 arg3 = static_cast<int >(SWIG_As_int(obj2));
8577 if (SWIG_arg_fail(3)) SWIG_fail;
8578 }
8579 }
8580 {
8581 PyThreadState* __tstate = wxPyBeginAllowThreads();
8582 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8583
8584 wxPyEndAllowThreads(__tstate);
8585 if (PyErr_Occurred()) SWIG_fail;
8586 }
8587 {
8588 #if wxUSE_UNICODE
8589 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8590 #else
8591 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8592 #endif
8593 }
8594 {
8595 if (temp2)
8596 delete arg2;
8597 }
8598 return resultobj;
8599 fail:
8600 {
8601 if (temp2)
8602 delete arg2;
8603 }
8604 return NULL;
8605 }
8606
8607
8608 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8609 PyObject *resultobj = NULL;
8610 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8611 wxString result;
8612 PyObject * obj0 = 0 ;
8613 char *kwnames[] = {
8614 (char *) "self", NULL
8615 };
8616
8617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8619 if (SWIG_arg_fail(1)) SWIG_fail;
8620 {
8621 PyThreadState* __tstate = wxPyBeginAllowThreads();
8622 result = (arg1)->FindNext();
8623
8624 wxPyEndAllowThreads(__tstate);
8625 if (PyErr_Occurred()) SWIG_fail;
8626 }
8627 {
8628 #if wxUSE_UNICODE
8629 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8630 #else
8631 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8632 #endif
8633 }
8634 return resultobj;
8635 fail:
8636 return NULL;
8637 }
8638
8639
8640 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8641 PyObject *resultobj = NULL;
8642 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8643 wxString *arg2 = 0 ;
8644 wxString result;
8645 bool temp2 = false ;
8646 PyObject * obj0 = 0 ;
8647 PyObject * obj1 = 0 ;
8648 char *kwnames[] = {
8649 (char *) "self",(char *) "location", NULL
8650 };
8651
8652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8654 if (SWIG_arg_fail(1)) SWIG_fail;
8655 {
8656 arg2 = wxString_in_helper(obj1);
8657 if (arg2 == NULL) SWIG_fail;
8658 temp2 = true;
8659 }
8660 {
8661 PyThreadState* __tstate = wxPyBeginAllowThreads();
8662 result = (arg1)->GetProtocol((wxString const &)*arg2);
8663
8664 wxPyEndAllowThreads(__tstate);
8665 if (PyErr_Occurred()) SWIG_fail;
8666 }
8667 {
8668 #if wxUSE_UNICODE
8669 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8670 #else
8671 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8672 #endif
8673 }
8674 {
8675 if (temp2)
8676 delete arg2;
8677 }
8678 return resultobj;
8679 fail:
8680 {
8681 if (temp2)
8682 delete arg2;
8683 }
8684 return NULL;
8685 }
8686
8687
8688 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8689 PyObject *resultobj = NULL;
8690 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8691 wxString *arg2 = 0 ;
8692 wxString result;
8693 bool temp2 = false ;
8694 PyObject * obj0 = 0 ;
8695 PyObject * obj1 = 0 ;
8696 char *kwnames[] = {
8697 (char *) "self",(char *) "location", NULL
8698 };
8699
8700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8702 if (SWIG_arg_fail(1)) SWIG_fail;
8703 {
8704 arg2 = wxString_in_helper(obj1);
8705 if (arg2 == NULL) SWIG_fail;
8706 temp2 = true;
8707 }
8708 {
8709 PyThreadState* __tstate = wxPyBeginAllowThreads();
8710 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8711
8712 wxPyEndAllowThreads(__tstate);
8713 if (PyErr_Occurred()) SWIG_fail;
8714 }
8715 {
8716 #if wxUSE_UNICODE
8717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8718 #else
8719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8720 #endif
8721 }
8722 {
8723 if (temp2)
8724 delete arg2;
8725 }
8726 return resultobj;
8727 fail:
8728 {
8729 if (temp2)
8730 delete arg2;
8731 }
8732 return NULL;
8733 }
8734
8735
8736 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8737 PyObject *resultobj = NULL;
8738 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8739 wxString *arg2 = 0 ;
8740 wxString result;
8741 bool temp2 = false ;
8742 PyObject * obj0 = 0 ;
8743 PyObject * obj1 = 0 ;
8744 char *kwnames[] = {
8745 (char *) "self",(char *) "location", NULL
8746 };
8747
8748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8750 if (SWIG_arg_fail(1)) SWIG_fail;
8751 {
8752 arg2 = wxString_in_helper(obj1);
8753 if (arg2 == NULL) SWIG_fail;
8754 temp2 = true;
8755 }
8756 {
8757 PyThreadState* __tstate = wxPyBeginAllowThreads();
8758 result = (arg1)->GetAnchor((wxString const &)*arg2);
8759
8760 wxPyEndAllowThreads(__tstate);
8761 if (PyErr_Occurred()) SWIG_fail;
8762 }
8763 {
8764 #if wxUSE_UNICODE
8765 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8766 #else
8767 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8768 #endif
8769 }
8770 {
8771 if (temp2)
8772 delete arg2;
8773 }
8774 return resultobj;
8775 fail:
8776 {
8777 if (temp2)
8778 delete arg2;
8779 }
8780 return NULL;
8781 }
8782
8783
8784 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8785 PyObject *resultobj = NULL;
8786 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8787 wxString *arg2 = 0 ;
8788 wxString result;
8789 bool temp2 = false ;
8790 PyObject * obj0 = 0 ;
8791 PyObject * obj1 = 0 ;
8792 char *kwnames[] = {
8793 (char *) "self",(char *) "location", NULL
8794 };
8795
8796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8798 if (SWIG_arg_fail(1)) SWIG_fail;
8799 {
8800 arg2 = wxString_in_helper(obj1);
8801 if (arg2 == NULL) SWIG_fail;
8802 temp2 = true;
8803 }
8804 {
8805 PyThreadState* __tstate = wxPyBeginAllowThreads();
8806 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8807
8808 wxPyEndAllowThreads(__tstate);
8809 if (PyErr_Occurred()) SWIG_fail;
8810 }
8811 {
8812 #if wxUSE_UNICODE
8813 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8814 #else
8815 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8816 #endif
8817 }
8818 {
8819 if (temp2)
8820 delete arg2;
8821 }
8822 return resultobj;
8823 fail:
8824 {
8825 if (temp2)
8826 delete arg2;
8827 }
8828 return NULL;
8829 }
8830
8831
8832 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8833 PyObject *resultobj = NULL;
8834 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8835 wxString *arg2 = 0 ;
8836 wxString result;
8837 bool temp2 = false ;
8838 PyObject * obj0 = 0 ;
8839 PyObject * obj1 = 0 ;
8840 char *kwnames[] = {
8841 (char *) "self",(char *) "location", NULL
8842 };
8843
8844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8846 if (SWIG_arg_fail(1)) SWIG_fail;
8847 {
8848 arg2 = wxString_in_helper(obj1);
8849 if (arg2 == NULL) SWIG_fail;
8850 temp2 = true;
8851 }
8852 {
8853 PyThreadState* __tstate = wxPyBeginAllowThreads();
8854 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8855
8856 wxPyEndAllowThreads(__tstate);
8857 if (PyErr_Occurred()) SWIG_fail;
8858 }
8859 {
8860 #if wxUSE_UNICODE
8861 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8862 #else
8863 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8864 #endif
8865 }
8866 {
8867 if (temp2)
8868 delete arg2;
8869 }
8870 return resultobj;
8871 fail:
8872 {
8873 if (temp2)
8874 delete arg2;
8875 }
8876 return NULL;
8877 }
8878
8879
8880 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8881 PyObject *obj;
8882 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8883 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8884 Py_INCREF(obj);
8885 return Py_BuildValue((char *)"");
8886 }
8887 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8888 PyObject *resultobj = NULL;
8889 wxFileSystem *result;
8890 char *kwnames[] = {
8891 NULL
8892 };
8893
8894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8895 {
8896 PyThreadState* __tstate = wxPyBeginAllowThreads();
8897 result = (wxFileSystem *)new wxFileSystem();
8898
8899 wxPyEndAllowThreads(__tstate);
8900 if (PyErr_Occurred()) SWIG_fail;
8901 }
8902 {
8903 resultobj = wxPyMake_wxObject(result, 1);
8904 }
8905 return resultobj;
8906 fail:
8907 return NULL;
8908 }
8909
8910
8911 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8912 PyObject *resultobj = NULL;
8913 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8914 PyObject * obj0 = 0 ;
8915 char *kwnames[] = {
8916 (char *) "self", NULL
8917 };
8918
8919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8921 if (SWIG_arg_fail(1)) SWIG_fail;
8922 {
8923 PyThreadState* __tstate = wxPyBeginAllowThreads();
8924 delete arg1;
8925
8926 wxPyEndAllowThreads(__tstate);
8927 if (PyErr_Occurred()) SWIG_fail;
8928 }
8929 Py_INCREF(Py_None); resultobj = Py_None;
8930 return resultobj;
8931 fail:
8932 return NULL;
8933 }
8934
8935
8936 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8937 PyObject *resultobj = NULL;
8938 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8939 wxString *arg2 = 0 ;
8940 bool arg3 = (bool) false ;
8941 bool temp2 = false ;
8942 PyObject * obj0 = 0 ;
8943 PyObject * obj1 = 0 ;
8944 PyObject * obj2 = 0 ;
8945 char *kwnames[] = {
8946 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8947 };
8948
8949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8951 if (SWIG_arg_fail(1)) SWIG_fail;
8952 {
8953 arg2 = wxString_in_helper(obj1);
8954 if (arg2 == NULL) SWIG_fail;
8955 temp2 = true;
8956 }
8957 if (obj2) {
8958 {
8959 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
8960 if (SWIG_arg_fail(3)) SWIG_fail;
8961 }
8962 }
8963 {
8964 PyThreadState* __tstate = wxPyBeginAllowThreads();
8965 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8966
8967 wxPyEndAllowThreads(__tstate);
8968 if (PyErr_Occurred()) SWIG_fail;
8969 }
8970 Py_INCREF(Py_None); resultobj = Py_None;
8971 {
8972 if (temp2)
8973 delete arg2;
8974 }
8975 return resultobj;
8976 fail:
8977 {
8978 if (temp2)
8979 delete arg2;
8980 }
8981 return NULL;
8982 }
8983
8984
8985 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8986 PyObject *resultobj = NULL;
8987 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8988 wxString result;
8989 PyObject * obj0 = 0 ;
8990 char *kwnames[] = {
8991 (char *) "self", NULL
8992 };
8993
8994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8996 if (SWIG_arg_fail(1)) SWIG_fail;
8997 {
8998 PyThreadState* __tstate = wxPyBeginAllowThreads();
8999 result = (arg1)->GetPath();
9000
9001 wxPyEndAllowThreads(__tstate);
9002 if (PyErr_Occurred()) SWIG_fail;
9003 }
9004 {
9005 #if wxUSE_UNICODE
9006 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9007 #else
9008 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9009 #endif
9010 }
9011 return resultobj;
9012 fail:
9013 return NULL;
9014 }
9015
9016
9017 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9018 PyObject *resultobj = NULL;
9019 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9020 wxString *arg2 = 0 ;
9021 wxFSFile *result;
9022 bool temp2 = false ;
9023 PyObject * obj0 = 0 ;
9024 PyObject * obj1 = 0 ;
9025 char *kwnames[] = {
9026 (char *) "self",(char *) "location", NULL
9027 };
9028
9029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
9030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9031 if (SWIG_arg_fail(1)) SWIG_fail;
9032 {
9033 arg2 = wxString_in_helper(obj1);
9034 if (arg2 == NULL) SWIG_fail;
9035 temp2 = true;
9036 }
9037 {
9038 PyThreadState* __tstate = wxPyBeginAllowThreads();
9039 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
9040
9041 wxPyEndAllowThreads(__tstate);
9042 if (PyErr_Occurred()) SWIG_fail;
9043 }
9044 {
9045 resultobj = wxPyMake_wxObject(result, 1);
9046 }
9047 {
9048 if (temp2)
9049 delete arg2;
9050 }
9051 return resultobj;
9052 fail:
9053 {
9054 if (temp2)
9055 delete arg2;
9056 }
9057 return NULL;
9058 }
9059
9060
9061 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9062 PyObject *resultobj = NULL;
9063 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9064 wxString *arg2 = 0 ;
9065 int arg3 = (int) 0 ;
9066 wxString result;
9067 bool temp2 = false ;
9068 PyObject * obj0 = 0 ;
9069 PyObject * obj1 = 0 ;
9070 PyObject * obj2 = 0 ;
9071 char *kwnames[] = {
9072 (char *) "self",(char *) "spec",(char *) "flags", NULL
9073 };
9074
9075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9077 if (SWIG_arg_fail(1)) SWIG_fail;
9078 {
9079 arg2 = wxString_in_helper(obj1);
9080 if (arg2 == NULL) SWIG_fail;
9081 temp2 = true;
9082 }
9083 if (obj2) {
9084 {
9085 arg3 = static_cast<int >(SWIG_As_int(obj2));
9086 if (SWIG_arg_fail(3)) SWIG_fail;
9087 }
9088 }
9089 {
9090 PyThreadState* __tstate = wxPyBeginAllowThreads();
9091 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9092
9093 wxPyEndAllowThreads(__tstate);
9094 if (PyErr_Occurred()) SWIG_fail;
9095 }
9096 {
9097 #if wxUSE_UNICODE
9098 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9099 #else
9100 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9101 #endif
9102 }
9103 {
9104 if (temp2)
9105 delete arg2;
9106 }
9107 return resultobj;
9108 fail:
9109 {
9110 if (temp2)
9111 delete arg2;
9112 }
9113 return NULL;
9114 }
9115
9116
9117 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9118 PyObject *resultobj = NULL;
9119 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9120 wxString result;
9121 PyObject * obj0 = 0 ;
9122 char *kwnames[] = {
9123 (char *) "self", NULL
9124 };
9125
9126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
9127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9128 if (SWIG_arg_fail(1)) SWIG_fail;
9129 {
9130 PyThreadState* __tstate = wxPyBeginAllowThreads();
9131 result = (arg1)->FindNext();
9132
9133 wxPyEndAllowThreads(__tstate);
9134 if (PyErr_Occurred()) SWIG_fail;
9135 }
9136 {
9137 #if wxUSE_UNICODE
9138 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9139 #else
9140 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9141 #endif
9142 }
9143 return resultobj;
9144 fail:
9145 return NULL;
9146 }
9147
9148
9149 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9150 PyObject *resultobj = NULL;
9151 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9152 PyObject * obj0 = 0 ;
9153 char *kwnames[] = {
9154 (char *) "handler", NULL
9155 };
9156
9157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9159 if (SWIG_arg_fail(1)) SWIG_fail;
9160 {
9161 PyThreadState* __tstate = wxPyBeginAllowThreads();
9162 wxFileSystem::AddHandler(arg1);
9163
9164 wxPyEndAllowThreads(__tstate);
9165 if (PyErr_Occurred()) SWIG_fail;
9166 }
9167 Py_INCREF(Py_None); resultobj = Py_None;
9168 return resultobj;
9169 fail:
9170 return NULL;
9171 }
9172
9173
9174 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9175 PyObject *resultobj = NULL;
9176 char *kwnames[] = {
9177 NULL
9178 };
9179
9180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9181 {
9182 PyThreadState* __tstate = wxPyBeginAllowThreads();
9183 wxFileSystem::CleanUpHandlers();
9184
9185 wxPyEndAllowThreads(__tstate);
9186 if (PyErr_Occurred()) SWIG_fail;
9187 }
9188 Py_INCREF(Py_None); resultobj = Py_None;
9189 return resultobj;
9190 fail:
9191 return NULL;
9192 }
9193
9194
9195 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9196 PyObject *resultobj = NULL;
9197 wxString *arg1 = 0 ;
9198 wxString result;
9199 bool temp1 = false ;
9200 PyObject * obj0 = 0 ;
9201 char *kwnames[] = {
9202 (char *) "filename", NULL
9203 };
9204
9205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9206 {
9207 arg1 = wxString_in_helper(obj0);
9208 if (arg1 == NULL) SWIG_fail;
9209 temp1 = true;
9210 }
9211 {
9212 PyThreadState* __tstate = wxPyBeginAllowThreads();
9213 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9214
9215 wxPyEndAllowThreads(__tstate);
9216 if (PyErr_Occurred()) SWIG_fail;
9217 }
9218 {
9219 #if wxUSE_UNICODE
9220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9221 #else
9222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9223 #endif
9224 }
9225 {
9226 if (temp1)
9227 delete arg1;
9228 }
9229 return resultobj;
9230 fail:
9231 {
9232 if (temp1)
9233 delete arg1;
9234 }
9235 return NULL;
9236 }
9237
9238
9239 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9240 PyObject *resultobj = NULL;
9241 wxString *arg1 = 0 ;
9242 wxString result;
9243 bool temp1 = false ;
9244 PyObject * obj0 = 0 ;
9245 char *kwnames[] = {
9246 (char *) "url", NULL
9247 };
9248
9249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9250 {
9251 arg1 = wxString_in_helper(obj0);
9252 if (arg1 == NULL) SWIG_fail;
9253 temp1 = true;
9254 }
9255 {
9256 PyThreadState* __tstate = wxPyBeginAllowThreads();
9257 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
9258
9259 wxPyEndAllowThreads(__tstate);
9260 if (PyErr_Occurred()) SWIG_fail;
9261 }
9262 {
9263 #if wxUSE_UNICODE
9264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9265 #else
9266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9267 #endif
9268 }
9269 {
9270 if (temp1)
9271 delete arg1;
9272 }
9273 return resultobj;
9274 fail:
9275 {
9276 if (temp1)
9277 delete arg1;
9278 }
9279 return NULL;
9280 }
9281
9282
9283 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9284 PyObject *obj;
9285 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9286 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9287 Py_INCREF(obj);
9288 return Py_BuildValue((char *)"");
9289 }
9290 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9291 PyObject *resultobj = NULL;
9292 wxInternetFSHandler *result;
9293 char *kwnames[] = {
9294 NULL
9295 };
9296
9297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9298 {
9299 PyThreadState* __tstate = wxPyBeginAllowThreads();
9300 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9301
9302 wxPyEndAllowThreads(__tstate);
9303 if (PyErr_Occurred()) SWIG_fail;
9304 }
9305 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9306 return resultobj;
9307 fail:
9308 return NULL;
9309 }
9310
9311
9312 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9313 PyObject *resultobj = NULL;
9314 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9315 wxString *arg2 = 0 ;
9316 bool result;
9317 bool temp2 = false ;
9318 PyObject * obj0 = 0 ;
9319 PyObject * obj1 = 0 ;
9320 char *kwnames[] = {
9321 (char *) "self",(char *) "location", NULL
9322 };
9323
9324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9326 if (SWIG_arg_fail(1)) SWIG_fail;
9327 {
9328 arg2 = wxString_in_helper(obj1);
9329 if (arg2 == NULL) SWIG_fail;
9330 temp2 = true;
9331 }
9332 {
9333 PyThreadState* __tstate = wxPyBeginAllowThreads();
9334 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9335
9336 wxPyEndAllowThreads(__tstate);
9337 if (PyErr_Occurred()) SWIG_fail;
9338 }
9339 {
9340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9341 }
9342 {
9343 if (temp2)
9344 delete arg2;
9345 }
9346 return resultobj;
9347 fail:
9348 {
9349 if (temp2)
9350 delete arg2;
9351 }
9352 return NULL;
9353 }
9354
9355
9356 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9357 PyObject *resultobj = NULL;
9358 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9359 wxFileSystem *arg2 = 0 ;
9360 wxString *arg3 = 0 ;
9361 wxFSFile *result;
9362 bool temp3 = false ;
9363 PyObject * obj0 = 0 ;
9364 PyObject * obj1 = 0 ;
9365 PyObject * obj2 = 0 ;
9366 char *kwnames[] = {
9367 (char *) "self",(char *) "fs",(char *) "location", NULL
9368 };
9369
9370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9372 if (SWIG_arg_fail(1)) SWIG_fail;
9373 {
9374 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9375 if (SWIG_arg_fail(2)) SWIG_fail;
9376 if (arg2 == NULL) {
9377 SWIG_null_ref("wxFileSystem");
9378 }
9379 if (SWIG_arg_fail(2)) SWIG_fail;
9380 }
9381 {
9382 arg3 = wxString_in_helper(obj2);
9383 if (arg3 == NULL) SWIG_fail;
9384 temp3 = true;
9385 }
9386 {
9387 PyThreadState* __tstate = wxPyBeginAllowThreads();
9388 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9389
9390 wxPyEndAllowThreads(__tstate);
9391 if (PyErr_Occurred()) SWIG_fail;
9392 }
9393 {
9394 resultobj = wxPyMake_wxObject(result, 1);
9395 }
9396 {
9397 if (temp3)
9398 delete arg3;
9399 }
9400 return resultobj;
9401 fail:
9402 {
9403 if (temp3)
9404 delete arg3;
9405 }
9406 return NULL;
9407 }
9408
9409
9410 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9411 PyObject *obj;
9412 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9413 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9414 Py_INCREF(obj);
9415 return Py_BuildValue((char *)"");
9416 }
9417 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9418 PyObject *resultobj = NULL;
9419 wxZipFSHandler *result;
9420 char *kwnames[] = {
9421 NULL
9422 };
9423
9424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9425 {
9426 PyThreadState* __tstate = wxPyBeginAllowThreads();
9427 result = (wxZipFSHandler *)new wxZipFSHandler();
9428
9429 wxPyEndAllowThreads(__tstate);
9430 if (PyErr_Occurred()) SWIG_fail;
9431 }
9432 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9433 return resultobj;
9434 fail:
9435 return NULL;
9436 }
9437
9438
9439 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9440 PyObject *resultobj = NULL;
9441 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9442 wxString *arg2 = 0 ;
9443 bool result;
9444 bool temp2 = false ;
9445 PyObject * obj0 = 0 ;
9446 PyObject * obj1 = 0 ;
9447 char *kwnames[] = {
9448 (char *) "self",(char *) "location", NULL
9449 };
9450
9451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9453 if (SWIG_arg_fail(1)) SWIG_fail;
9454 {
9455 arg2 = wxString_in_helper(obj1);
9456 if (arg2 == NULL) SWIG_fail;
9457 temp2 = true;
9458 }
9459 {
9460 PyThreadState* __tstate = wxPyBeginAllowThreads();
9461 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9462
9463 wxPyEndAllowThreads(__tstate);
9464 if (PyErr_Occurred()) SWIG_fail;
9465 }
9466 {
9467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9468 }
9469 {
9470 if (temp2)
9471 delete arg2;
9472 }
9473 return resultobj;
9474 fail:
9475 {
9476 if (temp2)
9477 delete arg2;
9478 }
9479 return NULL;
9480 }
9481
9482
9483 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9484 PyObject *resultobj = NULL;
9485 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9486 wxFileSystem *arg2 = 0 ;
9487 wxString *arg3 = 0 ;
9488 wxFSFile *result;
9489 bool temp3 = false ;
9490 PyObject * obj0 = 0 ;
9491 PyObject * obj1 = 0 ;
9492 PyObject * obj2 = 0 ;
9493 char *kwnames[] = {
9494 (char *) "self",(char *) "fs",(char *) "location", NULL
9495 };
9496
9497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9499 if (SWIG_arg_fail(1)) SWIG_fail;
9500 {
9501 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9502 if (SWIG_arg_fail(2)) SWIG_fail;
9503 if (arg2 == NULL) {
9504 SWIG_null_ref("wxFileSystem");
9505 }
9506 if (SWIG_arg_fail(2)) SWIG_fail;
9507 }
9508 {
9509 arg3 = wxString_in_helper(obj2);
9510 if (arg3 == NULL) SWIG_fail;
9511 temp3 = true;
9512 }
9513 {
9514 PyThreadState* __tstate = wxPyBeginAllowThreads();
9515 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9516
9517 wxPyEndAllowThreads(__tstate);
9518 if (PyErr_Occurred()) SWIG_fail;
9519 }
9520 {
9521 resultobj = wxPyMake_wxObject(result, 1);
9522 }
9523 {
9524 if (temp3)
9525 delete arg3;
9526 }
9527 return resultobj;
9528 fail:
9529 {
9530 if (temp3)
9531 delete arg3;
9532 }
9533 return NULL;
9534 }
9535
9536
9537 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9538 PyObject *resultobj = NULL;
9539 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9540 wxString *arg2 = 0 ;
9541 int arg3 = (int) 0 ;
9542 wxString result;
9543 bool temp2 = false ;
9544 PyObject * obj0 = 0 ;
9545 PyObject * obj1 = 0 ;
9546 PyObject * obj2 = 0 ;
9547 char *kwnames[] = {
9548 (char *) "self",(char *) "spec",(char *) "flags", NULL
9549 };
9550
9551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9553 if (SWIG_arg_fail(1)) SWIG_fail;
9554 {
9555 arg2 = wxString_in_helper(obj1);
9556 if (arg2 == NULL) SWIG_fail;
9557 temp2 = true;
9558 }
9559 if (obj2) {
9560 {
9561 arg3 = static_cast<int >(SWIG_As_int(obj2));
9562 if (SWIG_arg_fail(3)) SWIG_fail;
9563 }
9564 }
9565 {
9566 PyThreadState* __tstate = wxPyBeginAllowThreads();
9567 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9568
9569 wxPyEndAllowThreads(__tstate);
9570 if (PyErr_Occurred()) SWIG_fail;
9571 }
9572 {
9573 #if wxUSE_UNICODE
9574 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9575 #else
9576 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9577 #endif
9578 }
9579 {
9580 if (temp2)
9581 delete arg2;
9582 }
9583 return resultobj;
9584 fail:
9585 {
9586 if (temp2)
9587 delete arg2;
9588 }
9589 return NULL;
9590 }
9591
9592
9593 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9594 PyObject *resultobj = NULL;
9595 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9596 wxString result;
9597 PyObject * obj0 = 0 ;
9598 char *kwnames[] = {
9599 (char *) "self", NULL
9600 };
9601
9602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9604 if (SWIG_arg_fail(1)) SWIG_fail;
9605 {
9606 PyThreadState* __tstate = wxPyBeginAllowThreads();
9607 result = (arg1)->FindNext();
9608
9609 wxPyEndAllowThreads(__tstate);
9610 if (PyErr_Occurred()) SWIG_fail;
9611 }
9612 {
9613 #if wxUSE_UNICODE
9614 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9615 #else
9616 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9617 #endif
9618 }
9619 return resultobj;
9620 fail:
9621 return NULL;
9622 }
9623
9624
9625 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9626 PyObject *obj;
9627 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9628 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9629 Py_INCREF(obj);
9630 return Py_BuildValue((char *)"");
9631 }
9632 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9633 PyObject *resultobj = NULL;
9634 wxString *arg1 = 0 ;
9635 wxImage *arg2 = 0 ;
9636 long arg3 ;
9637 bool temp1 = false ;
9638 PyObject * obj0 = 0 ;
9639 PyObject * obj1 = 0 ;
9640 PyObject * obj2 = 0 ;
9641 char *kwnames[] = {
9642 (char *) "filename",(char *) "image",(char *) "type", NULL
9643 };
9644
9645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9646 {
9647 arg1 = wxString_in_helper(obj0);
9648 if (arg1 == NULL) SWIG_fail;
9649 temp1 = true;
9650 }
9651 {
9652 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9653 if (SWIG_arg_fail(2)) SWIG_fail;
9654 if (arg2 == NULL) {
9655 SWIG_null_ref("wxImage");
9656 }
9657 if (SWIG_arg_fail(2)) SWIG_fail;
9658 }
9659 {
9660 arg3 = static_cast<long >(SWIG_As_long(obj2));
9661 if (SWIG_arg_fail(3)) SWIG_fail;
9662 }
9663 {
9664 PyThreadState* __tstate = wxPyBeginAllowThreads();
9665 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9666
9667 wxPyEndAllowThreads(__tstate);
9668 if (PyErr_Occurred()) SWIG_fail;
9669 }
9670 Py_INCREF(Py_None); resultobj = Py_None;
9671 {
9672 if (temp1)
9673 delete arg1;
9674 }
9675 return resultobj;
9676 fail:
9677 {
9678 if (temp1)
9679 delete arg1;
9680 }
9681 return NULL;
9682 }
9683
9684
9685 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9686 PyObject *resultobj = NULL;
9687 wxString *arg1 = 0 ;
9688 wxBitmap *arg2 = 0 ;
9689 long arg3 ;
9690 bool temp1 = false ;
9691 PyObject * obj0 = 0 ;
9692 PyObject * obj1 = 0 ;
9693 PyObject * obj2 = 0 ;
9694 char *kwnames[] = {
9695 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9696 };
9697
9698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9699 {
9700 arg1 = wxString_in_helper(obj0);
9701 if (arg1 == NULL) SWIG_fail;
9702 temp1 = true;
9703 }
9704 {
9705 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9706 if (SWIG_arg_fail(2)) SWIG_fail;
9707 if (arg2 == NULL) {
9708 SWIG_null_ref("wxBitmap");
9709 }
9710 if (SWIG_arg_fail(2)) SWIG_fail;
9711 }
9712 {
9713 arg3 = static_cast<long >(SWIG_As_long(obj2));
9714 if (SWIG_arg_fail(3)) SWIG_fail;
9715 }
9716 {
9717 PyThreadState* __tstate = wxPyBeginAllowThreads();
9718 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9719
9720 wxPyEndAllowThreads(__tstate);
9721 if (PyErr_Occurred()) SWIG_fail;
9722 }
9723 Py_INCREF(Py_None); resultobj = Py_None;
9724 {
9725 if (temp1)
9726 delete arg1;
9727 }
9728 return resultobj;
9729 fail:
9730 {
9731 if (temp1)
9732 delete arg1;
9733 }
9734 return NULL;
9735 }
9736
9737
9738 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9739 PyObject *resultobj = NULL;
9740 wxString *arg1 = 0 ;
9741 PyObject *arg2 = (PyObject *) 0 ;
9742 bool temp1 = false ;
9743 PyObject * obj0 = 0 ;
9744 PyObject * obj1 = 0 ;
9745 char *kwnames[] = {
9746 (char *) "filename",(char *) "data", NULL
9747 };
9748
9749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9750 {
9751 arg1 = wxString_in_helper(obj0);
9752 if (arg1 == NULL) SWIG_fail;
9753 temp1 = true;
9754 }
9755 arg2 = obj1;
9756 {
9757 PyThreadState* __tstate = wxPyBeginAllowThreads();
9758 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9759
9760 wxPyEndAllowThreads(__tstate);
9761 if (PyErr_Occurred()) SWIG_fail;
9762 }
9763 Py_INCREF(Py_None); resultobj = Py_None;
9764 {
9765 if (temp1)
9766 delete arg1;
9767 }
9768 return resultobj;
9769 fail:
9770 {
9771 if (temp1)
9772 delete arg1;
9773 }
9774 return NULL;
9775 }
9776
9777
9778 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9779 PyObject *resultobj = NULL;
9780 wxMemoryFSHandler *result;
9781 char *kwnames[] = {
9782 NULL
9783 };
9784
9785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9786 {
9787 PyThreadState* __tstate = wxPyBeginAllowThreads();
9788 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9789
9790 wxPyEndAllowThreads(__tstate);
9791 if (PyErr_Occurred()) SWIG_fail;
9792 }
9793 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9794 return resultobj;
9795 fail:
9796 return NULL;
9797 }
9798
9799
9800 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9801 PyObject *resultobj = NULL;
9802 wxString *arg1 = 0 ;
9803 bool temp1 = false ;
9804 PyObject * obj0 = 0 ;
9805 char *kwnames[] = {
9806 (char *) "filename", NULL
9807 };
9808
9809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9810 {
9811 arg1 = wxString_in_helper(obj0);
9812 if (arg1 == NULL) SWIG_fail;
9813 temp1 = true;
9814 }
9815 {
9816 PyThreadState* __tstate = wxPyBeginAllowThreads();
9817 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9818
9819 wxPyEndAllowThreads(__tstate);
9820 if (PyErr_Occurred()) SWIG_fail;
9821 }
9822 Py_INCREF(Py_None); resultobj = Py_None;
9823 {
9824 if (temp1)
9825 delete arg1;
9826 }
9827 return resultobj;
9828 fail:
9829 {
9830 if (temp1)
9831 delete arg1;
9832 }
9833 return NULL;
9834 }
9835
9836
9837 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9838 PyObject *resultobj = NULL;
9839 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9840 wxString *arg2 = 0 ;
9841 bool result;
9842 bool temp2 = false ;
9843 PyObject * obj0 = 0 ;
9844 PyObject * obj1 = 0 ;
9845 char *kwnames[] = {
9846 (char *) "self",(char *) "location", NULL
9847 };
9848
9849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9851 if (SWIG_arg_fail(1)) SWIG_fail;
9852 {
9853 arg2 = wxString_in_helper(obj1);
9854 if (arg2 == NULL) SWIG_fail;
9855 temp2 = true;
9856 }
9857 {
9858 PyThreadState* __tstate = wxPyBeginAllowThreads();
9859 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9860
9861 wxPyEndAllowThreads(__tstate);
9862 if (PyErr_Occurred()) SWIG_fail;
9863 }
9864 {
9865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9866 }
9867 {
9868 if (temp2)
9869 delete arg2;
9870 }
9871 return resultobj;
9872 fail:
9873 {
9874 if (temp2)
9875 delete arg2;
9876 }
9877 return NULL;
9878 }
9879
9880
9881 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9882 PyObject *resultobj = NULL;
9883 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9884 wxFileSystem *arg2 = 0 ;
9885 wxString *arg3 = 0 ;
9886 wxFSFile *result;
9887 bool temp3 = false ;
9888 PyObject * obj0 = 0 ;
9889 PyObject * obj1 = 0 ;
9890 PyObject * obj2 = 0 ;
9891 char *kwnames[] = {
9892 (char *) "self",(char *) "fs",(char *) "location", NULL
9893 };
9894
9895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9897 if (SWIG_arg_fail(1)) SWIG_fail;
9898 {
9899 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9900 if (SWIG_arg_fail(2)) SWIG_fail;
9901 if (arg2 == NULL) {
9902 SWIG_null_ref("wxFileSystem");
9903 }
9904 if (SWIG_arg_fail(2)) SWIG_fail;
9905 }
9906 {
9907 arg3 = wxString_in_helper(obj2);
9908 if (arg3 == NULL) SWIG_fail;
9909 temp3 = true;
9910 }
9911 {
9912 PyThreadState* __tstate = wxPyBeginAllowThreads();
9913 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9914
9915 wxPyEndAllowThreads(__tstate);
9916 if (PyErr_Occurred()) SWIG_fail;
9917 }
9918 {
9919 resultobj = wxPyMake_wxObject(result, 1);
9920 }
9921 {
9922 if (temp3)
9923 delete arg3;
9924 }
9925 return resultobj;
9926 fail:
9927 {
9928 if (temp3)
9929 delete arg3;
9930 }
9931 return NULL;
9932 }
9933
9934
9935 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9936 PyObject *resultobj = NULL;
9937 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9938 wxString *arg2 = 0 ;
9939 int arg3 = (int) 0 ;
9940 wxString result;
9941 bool temp2 = false ;
9942 PyObject * obj0 = 0 ;
9943 PyObject * obj1 = 0 ;
9944 PyObject * obj2 = 0 ;
9945 char *kwnames[] = {
9946 (char *) "self",(char *) "spec",(char *) "flags", NULL
9947 };
9948
9949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9951 if (SWIG_arg_fail(1)) SWIG_fail;
9952 {
9953 arg2 = wxString_in_helper(obj1);
9954 if (arg2 == NULL) SWIG_fail;
9955 temp2 = true;
9956 }
9957 if (obj2) {
9958 {
9959 arg3 = static_cast<int >(SWIG_As_int(obj2));
9960 if (SWIG_arg_fail(3)) SWIG_fail;
9961 }
9962 }
9963 {
9964 PyThreadState* __tstate = wxPyBeginAllowThreads();
9965 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9966
9967 wxPyEndAllowThreads(__tstate);
9968 if (PyErr_Occurred()) SWIG_fail;
9969 }
9970 {
9971 #if wxUSE_UNICODE
9972 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9973 #else
9974 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9975 #endif
9976 }
9977 {
9978 if (temp2)
9979 delete arg2;
9980 }
9981 return resultobj;
9982 fail:
9983 {
9984 if (temp2)
9985 delete arg2;
9986 }
9987 return NULL;
9988 }
9989
9990
9991 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9992 PyObject *resultobj = NULL;
9993 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9994 wxString result;
9995 PyObject * obj0 = 0 ;
9996 char *kwnames[] = {
9997 (char *) "self", NULL
9998 };
9999
10000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
10001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
10002 if (SWIG_arg_fail(1)) SWIG_fail;
10003 {
10004 PyThreadState* __tstate = wxPyBeginAllowThreads();
10005 result = (arg1)->FindNext();
10006
10007 wxPyEndAllowThreads(__tstate);
10008 if (PyErr_Occurred()) SWIG_fail;
10009 }
10010 {
10011 #if wxUSE_UNICODE
10012 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10013 #else
10014 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10015 #endif
10016 }
10017 return resultobj;
10018 fail:
10019 return NULL;
10020 }
10021
10022
10023 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
10024 PyObject *obj;
10025 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10026 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
10027 Py_INCREF(obj);
10028 return Py_BuildValue((char *)"");
10029 }
10030 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
10031 PyObject *resultobj = NULL;
10032 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10033 wxString result;
10034 PyObject * obj0 = 0 ;
10035 char *kwnames[] = {
10036 (char *) "self", NULL
10037 };
10038
10039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
10040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10041 if (SWIG_arg_fail(1)) SWIG_fail;
10042 {
10043 PyThreadState* __tstate = wxPyBeginAllowThreads();
10044 result = (arg1)->GetName();
10045
10046 wxPyEndAllowThreads(__tstate);
10047 if (PyErr_Occurred()) SWIG_fail;
10048 }
10049 {
10050 #if wxUSE_UNICODE
10051 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10052 #else
10053 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10054 #endif
10055 }
10056 return resultobj;
10057 fail:
10058 return NULL;
10059 }
10060
10061
10062 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10063 PyObject *resultobj = NULL;
10064 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10065 wxString result;
10066 PyObject * obj0 = 0 ;
10067 char *kwnames[] = {
10068 (char *) "self", NULL
10069 };
10070
10071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
10072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10073 if (SWIG_arg_fail(1)) SWIG_fail;
10074 {
10075 PyThreadState* __tstate = wxPyBeginAllowThreads();
10076 result = (arg1)->GetExtension();
10077
10078 wxPyEndAllowThreads(__tstate);
10079 if (PyErr_Occurred()) SWIG_fail;
10080 }
10081 {
10082 #if wxUSE_UNICODE
10083 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10084 #else
10085 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10086 #endif
10087 }
10088 return resultobj;
10089 fail:
10090 return NULL;
10091 }
10092
10093
10094 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
10095 PyObject *resultobj = NULL;
10096 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10097 long result;
10098 PyObject * obj0 = 0 ;
10099 char *kwnames[] = {
10100 (char *) "self", NULL
10101 };
10102
10103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
10104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10105 if (SWIG_arg_fail(1)) SWIG_fail;
10106 {
10107 PyThreadState* __tstate = wxPyBeginAllowThreads();
10108 result = (long)(arg1)->GetType();
10109
10110 wxPyEndAllowThreads(__tstate);
10111 if (PyErr_Occurred()) SWIG_fail;
10112 }
10113 {
10114 resultobj = SWIG_From_long(static_cast<long >(result));
10115 }
10116 return resultobj;
10117 fail:
10118 return NULL;
10119 }
10120
10121
10122 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10123 PyObject *resultobj = NULL;
10124 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10125 wxString result;
10126 PyObject * obj0 = 0 ;
10127 char *kwnames[] = {
10128 (char *) "self", NULL
10129 };
10130
10131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
10132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10133 if (SWIG_arg_fail(1)) SWIG_fail;
10134 {
10135 PyThreadState* __tstate = wxPyBeginAllowThreads();
10136 result = (arg1)->GetMimeType();
10137
10138 wxPyEndAllowThreads(__tstate);
10139 if (PyErr_Occurred()) SWIG_fail;
10140 }
10141 {
10142 #if wxUSE_UNICODE
10143 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10144 #else
10145 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10146 #endif
10147 }
10148 return resultobj;
10149 fail:
10150 return NULL;
10151 }
10152
10153
10154 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10155 PyObject *resultobj = NULL;
10156 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10157 wxString *arg2 = 0 ;
10158 bool result;
10159 bool temp2 = false ;
10160 PyObject * obj0 = 0 ;
10161 PyObject * obj1 = 0 ;
10162 char *kwnames[] = {
10163 (char *) "self",(char *) "name", NULL
10164 };
10165
10166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10168 if (SWIG_arg_fail(1)) SWIG_fail;
10169 {
10170 arg2 = wxString_in_helper(obj1);
10171 if (arg2 == NULL) SWIG_fail;
10172 temp2 = true;
10173 }
10174 {
10175 PyThreadState* __tstate = wxPyBeginAllowThreads();
10176 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10177
10178 wxPyEndAllowThreads(__tstate);
10179 if (PyErr_Occurred()) SWIG_fail;
10180 }
10181 {
10182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10183 }
10184 {
10185 if (temp2)
10186 delete arg2;
10187 }
10188 return resultobj;
10189 fail:
10190 {
10191 if (temp2)
10192 delete arg2;
10193 }
10194 return NULL;
10195 }
10196
10197
10198 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10199 PyObject *resultobj = NULL;
10200 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10201 wxString *arg2 = 0 ;
10202 bool temp2 = false ;
10203 PyObject * obj0 = 0 ;
10204 PyObject * obj1 = 0 ;
10205 char *kwnames[] = {
10206 (char *) "self",(char *) "name", NULL
10207 };
10208
10209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10211 if (SWIG_arg_fail(1)) SWIG_fail;
10212 {
10213 arg2 = wxString_in_helper(obj1);
10214 if (arg2 == NULL) SWIG_fail;
10215 temp2 = true;
10216 }
10217 {
10218 PyThreadState* __tstate = wxPyBeginAllowThreads();
10219 (arg1)->SetName((wxString const &)*arg2);
10220
10221 wxPyEndAllowThreads(__tstate);
10222 if (PyErr_Occurred()) SWIG_fail;
10223 }
10224 Py_INCREF(Py_None); resultobj = Py_None;
10225 {
10226 if (temp2)
10227 delete arg2;
10228 }
10229 return resultobj;
10230 fail:
10231 {
10232 if (temp2)
10233 delete arg2;
10234 }
10235 return NULL;
10236 }
10237
10238
10239 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10240 PyObject *resultobj = NULL;
10241 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10242 wxString *arg2 = 0 ;
10243 bool temp2 = false ;
10244 PyObject * obj0 = 0 ;
10245 PyObject * obj1 = 0 ;
10246 char *kwnames[] = {
10247 (char *) "self",(char *) "extension", NULL
10248 };
10249
10250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10252 if (SWIG_arg_fail(1)) SWIG_fail;
10253 {
10254 arg2 = wxString_in_helper(obj1);
10255 if (arg2 == NULL) SWIG_fail;
10256 temp2 = true;
10257 }
10258 {
10259 PyThreadState* __tstate = wxPyBeginAllowThreads();
10260 (arg1)->SetExtension((wxString const &)*arg2);
10261
10262 wxPyEndAllowThreads(__tstate);
10263 if (PyErr_Occurred()) SWIG_fail;
10264 }
10265 Py_INCREF(Py_None); resultobj = Py_None;
10266 {
10267 if (temp2)
10268 delete arg2;
10269 }
10270 return resultobj;
10271 fail:
10272 {
10273 if (temp2)
10274 delete arg2;
10275 }
10276 return NULL;
10277 }
10278
10279
10280 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10281 PyObject *resultobj = NULL;
10282 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10283 long arg2 ;
10284 PyObject * obj0 = 0 ;
10285 PyObject * obj1 = 0 ;
10286 char *kwnames[] = {
10287 (char *) "self",(char *) "type", NULL
10288 };
10289
10290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10292 if (SWIG_arg_fail(1)) SWIG_fail;
10293 {
10294 arg2 = static_cast<long >(SWIG_As_long(obj1));
10295 if (SWIG_arg_fail(2)) SWIG_fail;
10296 }
10297 {
10298 PyThreadState* __tstate = wxPyBeginAllowThreads();
10299 (arg1)->SetType(arg2);
10300
10301 wxPyEndAllowThreads(__tstate);
10302 if (PyErr_Occurred()) SWIG_fail;
10303 }
10304 Py_INCREF(Py_None); resultobj = Py_None;
10305 return resultobj;
10306 fail:
10307 return NULL;
10308 }
10309
10310
10311 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10312 PyObject *resultobj = NULL;
10313 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10314 wxString *arg2 = 0 ;
10315 bool temp2 = false ;
10316 PyObject * obj0 = 0 ;
10317 PyObject * obj1 = 0 ;
10318 char *kwnames[] = {
10319 (char *) "self",(char *) "mimetype", NULL
10320 };
10321
10322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10324 if (SWIG_arg_fail(1)) SWIG_fail;
10325 {
10326 arg2 = wxString_in_helper(obj1);
10327 if (arg2 == NULL) SWIG_fail;
10328 temp2 = true;
10329 }
10330 {
10331 PyThreadState* __tstate = wxPyBeginAllowThreads();
10332 (arg1)->SetMimeType((wxString const &)*arg2);
10333
10334 wxPyEndAllowThreads(__tstate);
10335 if (PyErr_Occurred()) SWIG_fail;
10336 }
10337 Py_INCREF(Py_None); resultobj = Py_None;
10338 {
10339 if (temp2)
10340 delete arg2;
10341 }
10342 return resultobj;
10343 fail:
10344 {
10345 if (temp2)
10346 delete arg2;
10347 }
10348 return NULL;
10349 }
10350
10351
10352 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10353 PyObject *obj;
10354 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10355 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10356 Py_INCREF(obj);
10357 return Py_BuildValue((char *)"");
10358 }
10359 static PyObject *_wrap_new_PyImageHandler(PyObject *, PyObject *args, PyObject *kwargs) {
10360 PyObject *resultobj = NULL;
10361 wxPyImageHandler *result;
10362 char *kwnames[] = {
10363 NULL
10364 };
10365
10366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyImageHandler",kwnames)) goto fail;
10367 {
10368 PyThreadState* __tstate = wxPyBeginAllowThreads();
10369 result = (wxPyImageHandler *)new wxPyImageHandler();
10370
10371 wxPyEndAllowThreads(__tstate);
10372 if (PyErr_Occurred()) SWIG_fail;
10373 }
10374 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyImageHandler, 1);
10375 return resultobj;
10376 fail:
10377 return NULL;
10378 }
10379
10380
10381 static PyObject *_wrap_PyImageHandler__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
10382 PyObject *resultobj = NULL;
10383 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
10384 PyObject *arg2 = (PyObject *) 0 ;
10385 PyObject * obj0 = 0 ;
10386 PyObject * obj1 = 0 ;
10387 char *kwnames[] = {
10388 (char *) "self",(char *) "self", NULL
10389 };
10390
10391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) goto fail;
10392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_EXCEPTION | 0);
10393 if (SWIG_arg_fail(1)) SWIG_fail;
10394 arg2 = obj1;
10395 {
10396 PyThreadState* __tstate = wxPyBeginAllowThreads();
10397 (arg1)->_SetSelf(arg2);
10398
10399 wxPyEndAllowThreads(__tstate);
10400 if (PyErr_Occurred()) SWIG_fail;
10401 }
10402 Py_INCREF(Py_None); resultobj = Py_None;
10403 return resultobj;
10404 fail:
10405 return NULL;
10406 }
10407
10408
10409 static PyObject * PyImageHandler_swigregister(PyObject *, PyObject *args) {
10410 PyObject *obj;
10411 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10412 SWIG_TypeClientData(SWIGTYPE_p_wxPyImageHandler, obj);
10413 Py_INCREF(obj);
10414 return Py_BuildValue((char *)"");
10415 }
10416 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10417 PyObject *resultobj = NULL;
10418 wxImageHistogram *result;
10419 char *kwnames[] = {
10420 NULL
10421 };
10422
10423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10424 {
10425 PyThreadState* __tstate = wxPyBeginAllowThreads();
10426 result = (wxImageHistogram *)new wxImageHistogram();
10427
10428 wxPyEndAllowThreads(__tstate);
10429 if (PyErr_Occurred()) SWIG_fail;
10430 }
10431 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10432 return resultobj;
10433 fail:
10434 return NULL;
10435 }
10436
10437
10438 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10439 PyObject *resultobj = NULL;
10440 byte arg1 ;
10441 byte arg2 ;
10442 byte arg3 ;
10443 unsigned long result;
10444 PyObject * obj0 = 0 ;
10445 PyObject * obj1 = 0 ;
10446 PyObject * obj2 = 0 ;
10447 char *kwnames[] = {
10448 (char *) "r",(char *) "g",(char *) "b", NULL
10449 };
10450
10451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10452 {
10453 arg1 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj0));
10454 if (SWIG_arg_fail(1)) SWIG_fail;
10455 }
10456 {
10457 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10458 if (SWIG_arg_fail(2)) SWIG_fail;
10459 }
10460 {
10461 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10462 if (SWIG_arg_fail(3)) SWIG_fail;
10463 }
10464 {
10465 PyThreadState* __tstate = wxPyBeginAllowThreads();
10466 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10467
10468 wxPyEndAllowThreads(__tstate);
10469 if (PyErr_Occurred()) SWIG_fail;
10470 }
10471 {
10472 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10473 }
10474 return resultobj;
10475 fail:
10476 return NULL;
10477 }
10478
10479
10480 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10481 PyObject *resultobj = NULL;
10482 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10483 byte *arg2 = (byte *) 0 ;
10484 byte *arg3 = (byte *) 0 ;
10485 byte *arg4 = (byte *) 0 ;
10486 byte arg5 = (byte) 1 ;
10487 byte arg6 = (byte) 0 ;
10488 byte arg7 = (byte) 0 ;
10489 bool result;
10490 byte temp2 ;
10491 int res2 = 0 ;
10492 byte temp3 ;
10493 int res3 = 0 ;
10494 byte temp4 ;
10495 int res4 = 0 ;
10496 PyObject * obj0 = 0 ;
10497 PyObject * obj1 = 0 ;
10498 PyObject * obj2 = 0 ;
10499 PyObject * obj3 = 0 ;
10500 char *kwnames[] = {
10501 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10502 };
10503
10504 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10505 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10506 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10509 if (SWIG_arg_fail(1)) SWIG_fail;
10510 if (obj1) {
10511 {
10512 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10513 if (SWIG_arg_fail(5)) SWIG_fail;
10514 }
10515 }
10516 if (obj2) {
10517 {
10518 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10519 if (SWIG_arg_fail(6)) SWIG_fail;
10520 }
10521 }
10522 if (obj3) {
10523 {
10524 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
10525 if (SWIG_arg_fail(7)) SWIG_fail;
10526 }
10527 }
10528 {
10529 PyThreadState* __tstate = wxPyBeginAllowThreads();
10530 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10531
10532 wxPyEndAllowThreads(__tstate);
10533 if (PyErr_Occurred()) SWIG_fail;
10534 }
10535 {
10536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10537 }
10538 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10539 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10540 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10541 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10542 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10543 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10544 return resultobj;
10545 fail:
10546 return NULL;
10547 }
10548
10549
10550 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10551 PyObject *resultobj = NULL;
10552 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10553 unsigned long arg2 ;
10554 unsigned long result;
10555 PyObject * obj0 = 0 ;
10556 PyObject * obj1 = 0 ;
10557 char *kwnames[] = {
10558 (char *) "self",(char *) "key", NULL
10559 };
10560
10561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10563 if (SWIG_arg_fail(1)) SWIG_fail;
10564 {
10565 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
10566 if (SWIG_arg_fail(2)) SWIG_fail;
10567 }
10568 {
10569 PyThreadState* __tstate = wxPyBeginAllowThreads();
10570 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10571
10572 wxPyEndAllowThreads(__tstate);
10573 if (PyErr_Occurred()) SWIG_fail;
10574 }
10575 {
10576 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10577 }
10578 return resultobj;
10579 fail:
10580 return NULL;
10581 }
10582
10583
10584 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10585 PyObject *resultobj = NULL;
10586 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10587 byte arg2 ;
10588 byte arg3 ;
10589 byte arg4 ;
10590 unsigned long result;
10591 PyObject * obj0 = 0 ;
10592 PyObject * obj1 = 0 ;
10593 PyObject * obj2 = 0 ;
10594 PyObject * obj3 = 0 ;
10595 char *kwnames[] = {
10596 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10597 };
10598
10599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10601 if (SWIG_arg_fail(1)) SWIG_fail;
10602 {
10603 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10604 if (SWIG_arg_fail(2)) SWIG_fail;
10605 }
10606 {
10607 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10608 if (SWIG_arg_fail(3)) SWIG_fail;
10609 }
10610 {
10611 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
10612 if (SWIG_arg_fail(4)) SWIG_fail;
10613 }
10614 {
10615 PyThreadState* __tstate = wxPyBeginAllowThreads();
10616 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10617
10618 wxPyEndAllowThreads(__tstate);
10619 if (PyErr_Occurred()) SWIG_fail;
10620 }
10621 {
10622 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10623 }
10624 return resultobj;
10625 fail:
10626 return NULL;
10627 }
10628
10629
10630 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10631 PyObject *resultobj = NULL;
10632 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10633 wxColour *arg2 = 0 ;
10634 unsigned long result;
10635 wxColour temp2 ;
10636 PyObject * obj0 = 0 ;
10637 PyObject * obj1 = 0 ;
10638 char *kwnames[] = {
10639 (char *) "self",(char *) "colour", NULL
10640 };
10641
10642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10644 if (SWIG_arg_fail(1)) SWIG_fail;
10645 {
10646 arg2 = &temp2;
10647 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10648 }
10649 {
10650 PyThreadState* __tstate = wxPyBeginAllowThreads();
10651 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10652
10653 wxPyEndAllowThreads(__tstate);
10654 if (PyErr_Occurred()) SWIG_fail;
10655 }
10656 {
10657 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10658 }
10659 return resultobj;
10660 fail:
10661 return NULL;
10662 }
10663
10664
10665 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10666 PyObject *obj;
10667 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10668 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10669 Py_INCREF(obj);
10670 return Py_BuildValue((char *)"");
10671 }
10672 static PyObject *_wrap_new_Image_RGBValue(PyObject *, PyObject *args, PyObject *kwargs) {
10673 PyObject *resultobj = NULL;
10674 byte arg1 = (byte) 0 ;
10675 byte arg2 = (byte) 0 ;
10676 byte arg3 = (byte) 0 ;
10677 wxImage_RGBValue *result;
10678 PyObject * obj0 = 0 ;
10679 PyObject * obj1 = 0 ;
10680 PyObject * obj2 = 0 ;
10681 char *kwnames[] = {
10682 (char *) "r",(char *) "g",(char *) "b", NULL
10683 };
10684
10685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10686 if (obj0) {
10687 {
10688 arg1 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj0));
10689 if (SWIG_arg_fail(1)) SWIG_fail;
10690 }
10691 }
10692 if (obj1) {
10693 {
10694 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10695 if (SWIG_arg_fail(2)) SWIG_fail;
10696 }
10697 }
10698 if (obj2) {
10699 {
10700 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10701 if (SWIG_arg_fail(3)) SWIG_fail;
10702 }
10703 }
10704 {
10705 PyThreadState* __tstate = wxPyBeginAllowThreads();
10706 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
10707
10708 wxPyEndAllowThreads(__tstate);
10709 if (PyErr_Occurred()) SWIG_fail;
10710 }
10711 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_RGBValue, 1);
10712 return resultobj;
10713 fail:
10714 return NULL;
10715 }
10716
10717
10718 static PyObject *_wrap_Image_RGBValue_red_set(PyObject *, PyObject *args, PyObject *kwargs) {
10719 PyObject *resultobj = NULL;
10720 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10721 byte arg2 ;
10722 PyObject * obj0 = 0 ;
10723 PyObject * obj1 = 0 ;
10724 char *kwnames[] = {
10725 (char *) "self",(char *) "red", NULL
10726 };
10727
10728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_red_set",kwnames,&obj0,&obj1)) goto fail;
10729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10730 if (SWIG_arg_fail(1)) SWIG_fail;
10731 {
10732 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10733 if (SWIG_arg_fail(2)) SWIG_fail;
10734 }
10735 if (arg1) (arg1)->red = arg2;
10736
10737 Py_INCREF(Py_None); resultobj = Py_None;
10738 return resultobj;
10739 fail:
10740 return NULL;
10741 }
10742
10743
10744 static PyObject *_wrap_Image_RGBValue_red_get(PyObject *, PyObject *args, PyObject *kwargs) {
10745 PyObject *resultobj = NULL;
10746 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10747 byte result;
10748 PyObject * obj0 = 0 ;
10749 char *kwnames[] = {
10750 (char *) "self", NULL
10751 };
10752
10753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_red_get",kwnames,&obj0)) goto fail;
10754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10755 if (SWIG_arg_fail(1)) SWIG_fail;
10756 result = (byte) ((arg1)->red);
10757
10758 {
10759 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10760 }
10761 return resultobj;
10762 fail:
10763 return NULL;
10764 }
10765
10766
10767 static PyObject *_wrap_Image_RGBValue_green_set(PyObject *, PyObject *args, PyObject *kwargs) {
10768 PyObject *resultobj = NULL;
10769 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10770 byte arg2 ;
10771 PyObject * obj0 = 0 ;
10772 PyObject * obj1 = 0 ;
10773 char *kwnames[] = {
10774 (char *) "self",(char *) "green", NULL
10775 };
10776
10777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_green_set",kwnames,&obj0,&obj1)) goto fail;
10778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10779 if (SWIG_arg_fail(1)) SWIG_fail;
10780 {
10781 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10782 if (SWIG_arg_fail(2)) SWIG_fail;
10783 }
10784 if (arg1) (arg1)->green = arg2;
10785
10786 Py_INCREF(Py_None); resultobj = Py_None;
10787 return resultobj;
10788 fail:
10789 return NULL;
10790 }
10791
10792
10793 static PyObject *_wrap_Image_RGBValue_green_get(PyObject *, PyObject *args, PyObject *kwargs) {
10794 PyObject *resultobj = NULL;
10795 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10796 byte result;
10797 PyObject * obj0 = 0 ;
10798 char *kwnames[] = {
10799 (char *) "self", NULL
10800 };
10801
10802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_green_get",kwnames,&obj0)) goto fail;
10803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10804 if (SWIG_arg_fail(1)) SWIG_fail;
10805 result = (byte) ((arg1)->green);
10806
10807 {
10808 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10809 }
10810 return resultobj;
10811 fail:
10812 return NULL;
10813 }
10814
10815
10816 static PyObject *_wrap_Image_RGBValue_blue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10817 PyObject *resultobj = NULL;
10818 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10819 byte arg2 ;
10820 PyObject * obj0 = 0 ;
10821 PyObject * obj1 = 0 ;
10822 char *kwnames[] = {
10823 (char *) "self",(char *) "blue", NULL
10824 };
10825
10826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_blue_set",kwnames,&obj0,&obj1)) goto fail;
10827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10828 if (SWIG_arg_fail(1)) SWIG_fail;
10829 {
10830 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10831 if (SWIG_arg_fail(2)) SWIG_fail;
10832 }
10833 if (arg1) (arg1)->blue = arg2;
10834
10835 Py_INCREF(Py_None); resultobj = Py_None;
10836 return resultobj;
10837 fail:
10838 return NULL;
10839 }
10840
10841
10842 static PyObject *_wrap_Image_RGBValue_blue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10843 PyObject *resultobj = NULL;
10844 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10845 byte result;
10846 PyObject * obj0 = 0 ;
10847 char *kwnames[] = {
10848 (char *) "self", NULL
10849 };
10850
10851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_blue_get",kwnames,&obj0)) goto fail;
10852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10853 if (SWIG_arg_fail(1)) SWIG_fail;
10854 result = (byte) ((arg1)->blue);
10855
10856 {
10857 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10858 }
10859 return resultobj;
10860 fail:
10861 return NULL;
10862 }
10863
10864
10865 static PyObject * Image_RGBValue_swigregister(PyObject *, PyObject *args) {
10866 PyObject *obj;
10867 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10868 SWIG_TypeClientData(SWIGTYPE_p_wxImage_RGBValue, obj);
10869 Py_INCREF(obj);
10870 return Py_BuildValue((char *)"");
10871 }
10872 static PyObject *_wrap_new_Image_HSVValue(PyObject *, PyObject *args, PyObject *kwargs) {
10873 PyObject *resultobj = NULL;
10874 double arg1 = (double) 0.0 ;
10875 double arg2 = (double) 0.0 ;
10876 double arg3 = (double) 0.0 ;
10877 wxImage_HSVValue *result;
10878 PyObject * obj0 = 0 ;
10879 PyObject * obj1 = 0 ;
10880 PyObject * obj2 = 0 ;
10881 char *kwnames[] = {
10882 (char *) "h",(char *) "s",(char *) "v", NULL
10883 };
10884
10885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10886 if (obj0) {
10887 {
10888 arg1 = static_cast<double >(SWIG_As_double(obj0));
10889 if (SWIG_arg_fail(1)) SWIG_fail;
10890 }
10891 }
10892 if (obj1) {
10893 {
10894 arg2 = static_cast<double >(SWIG_As_double(obj1));
10895 if (SWIG_arg_fail(2)) SWIG_fail;
10896 }
10897 }
10898 if (obj2) {
10899 {
10900 arg3 = static_cast<double >(SWIG_As_double(obj2));
10901 if (SWIG_arg_fail(3)) SWIG_fail;
10902 }
10903 }
10904 {
10905 PyThreadState* __tstate = wxPyBeginAllowThreads();
10906 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
10907
10908 wxPyEndAllowThreads(__tstate);
10909 if (PyErr_Occurred()) SWIG_fail;
10910 }
10911 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_HSVValue, 1);
10912 return resultobj;
10913 fail:
10914 return NULL;
10915 }
10916
10917
10918 static PyObject *_wrap_Image_HSVValue_hue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10919 PyObject *resultobj = NULL;
10920 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10921 double arg2 ;
10922 PyObject * obj0 = 0 ;
10923 PyObject * obj1 = 0 ;
10924 char *kwnames[] = {
10925 (char *) "self",(char *) "hue", NULL
10926 };
10927
10928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_hue_set",kwnames,&obj0,&obj1)) goto fail;
10929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10930 if (SWIG_arg_fail(1)) SWIG_fail;
10931 {
10932 arg2 = static_cast<double >(SWIG_As_double(obj1));
10933 if (SWIG_arg_fail(2)) SWIG_fail;
10934 }
10935 if (arg1) (arg1)->hue = arg2;
10936
10937 Py_INCREF(Py_None); resultobj = Py_None;
10938 return resultobj;
10939 fail:
10940 return NULL;
10941 }
10942
10943
10944 static PyObject *_wrap_Image_HSVValue_hue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10945 PyObject *resultobj = NULL;
10946 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10947 double result;
10948 PyObject * obj0 = 0 ;
10949 char *kwnames[] = {
10950 (char *) "self", NULL
10951 };
10952
10953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_hue_get",kwnames,&obj0)) goto fail;
10954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10955 if (SWIG_arg_fail(1)) SWIG_fail;
10956 result = (double) ((arg1)->hue);
10957
10958 {
10959 resultobj = SWIG_From_double(static_cast<double >(result));
10960 }
10961 return resultobj;
10962 fail:
10963 return NULL;
10964 }
10965
10966
10967 static PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *, PyObject *args, PyObject *kwargs) {
10968 PyObject *resultobj = NULL;
10969 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10970 double arg2 ;
10971 PyObject * obj0 = 0 ;
10972 PyObject * obj1 = 0 ;
10973 char *kwnames[] = {
10974 (char *) "self",(char *) "saturation", NULL
10975 };
10976
10977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_saturation_set",kwnames,&obj0,&obj1)) goto fail;
10978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10979 if (SWIG_arg_fail(1)) SWIG_fail;
10980 {
10981 arg2 = static_cast<double >(SWIG_As_double(obj1));
10982 if (SWIG_arg_fail(2)) SWIG_fail;
10983 }
10984 if (arg1) (arg1)->saturation = arg2;
10985
10986 Py_INCREF(Py_None); resultobj = Py_None;
10987 return resultobj;
10988 fail:
10989 return NULL;
10990 }
10991
10992
10993 static PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *, PyObject *args, PyObject *kwargs) {
10994 PyObject *resultobj = NULL;
10995 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10996 double result;
10997 PyObject * obj0 = 0 ;
10998 char *kwnames[] = {
10999 (char *) "self", NULL
11000 };
11001
11002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_saturation_get",kwnames,&obj0)) goto fail;
11003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11004 if (SWIG_arg_fail(1)) SWIG_fail;
11005 result = (double) ((arg1)->saturation);
11006
11007 {
11008 resultobj = SWIG_From_double(static_cast<double >(result));
11009 }
11010 return resultobj;
11011 fail:
11012 return NULL;
11013 }
11014
11015
11016 static PyObject *_wrap_Image_HSVValue_value_set(PyObject *, PyObject *args, PyObject *kwargs) {
11017 PyObject *resultobj = NULL;
11018 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11019 double arg2 ;
11020 PyObject * obj0 = 0 ;
11021 PyObject * obj1 = 0 ;
11022 char *kwnames[] = {
11023 (char *) "self",(char *) "value", NULL
11024 };
11025
11026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_value_set",kwnames,&obj0,&obj1)) goto fail;
11027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11028 if (SWIG_arg_fail(1)) SWIG_fail;
11029 {
11030 arg2 = static_cast<double >(SWIG_As_double(obj1));
11031 if (SWIG_arg_fail(2)) SWIG_fail;
11032 }
11033 if (arg1) (arg1)->value = arg2;
11034
11035 Py_INCREF(Py_None); resultobj = Py_None;
11036 return resultobj;
11037 fail:
11038 return NULL;
11039 }
11040
11041
11042 static PyObject *_wrap_Image_HSVValue_value_get(PyObject *, PyObject *args, PyObject *kwargs) {
11043 PyObject *resultobj = NULL;
11044 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11045 double result;
11046 PyObject * obj0 = 0 ;
11047 char *kwnames[] = {
11048 (char *) "self", NULL
11049 };
11050
11051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_value_get",kwnames,&obj0)) goto fail;
11052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11053 if (SWIG_arg_fail(1)) SWIG_fail;
11054 result = (double) ((arg1)->value);
11055
11056 {
11057 resultobj = SWIG_From_double(static_cast<double >(result));
11058 }
11059 return resultobj;
11060 fail:
11061 return NULL;
11062 }
11063
11064
11065 static PyObject * Image_HSVValue_swigregister(PyObject *, PyObject *args) {
11066 PyObject *obj;
11067 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11068 SWIG_TypeClientData(SWIGTYPE_p_wxImage_HSVValue, obj);
11069 Py_INCREF(obj);
11070 return Py_BuildValue((char *)"");
11071 }
11072 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11073 PyObject *resultobj = NULL;
11074 wxString *arg1 = 0 ;
11075 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11076 int arg3 = (int) -1 ;
11077 wxImage *result;
11078 bool temp1 = false ;
11079 PyObject * obj0 = 0 ;
11080 PyObject * obj1 = 0 ;
11081 PyObject * obj2 = 0 ;
11082 char *kwnames[] = {
11083 (char *) "name",(char *) "type",(char *) "index", NULL
11084 };
11085
11086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
11087 {
11088 arg1 = wxString_in_helper(obj0);
11089 if (arg1 == NULL) SWIG_fail;
11090 temp1 = true;
11091 }
11092 if (obj1) {
11093 {
11094 arg2 = static_cast<long >(SWIG_As_long(obj1));
11095 if (SWIG_arg_fail(2)) SWIG_fail;
11096 }
11097 }
11098 if (obj2) {
11099 {
11100 arg3 = static_cast<int >(SWIG_As_int(obj2));
11101 if (SWIG_arg_fail(3)) SWIG_fail;
11102 }
11103 }
11104 {
11105 PyThreadState* __tstate = wxPyBeginAllowThreads();
11106 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
11107
11108 wxPyEndAllowThreads(__tstate);
11109 if (PyErr_Occurred()) SWIG_fail;
11110 }
11111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11112 {
11113 if (temp1)
11114 delete arg1;
11115 }
11116 return resultobj;
11117 fail:
11118 {
11119 if (temp1)
11120 delete arg1;
11121 }
11122 return NULL;
11123 }
11124
11125
11126 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11127 PyObject *resultobj = NULL;
11128 wxImage *arg1 = (wxImage *) 0 ;
11129 PyObject * obj0 = 0 ;
11130 char *kwnames[] = {
11131 (char *) "self", NULL
11132 };
11133
11134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
11135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11136 if (SWIG_arg_fail(1)) SWIG_fail;
11137 {
11138 PyThreadState* __tstate = wxPyBeginAllowThreads();
11139 delete arg1;
11140
11141 wxPyEndAllowThreads(__tstate);
11142 if (PyErr_Occurred()) SWIG_fail;
11143 }
11144 Py_INCREF(Py_None); resultobj = Py_None;
11145 return resultobj;
11146 fail:
11147 return NULL;
11148 }
11149
11150
11151 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
11152 PyObject *resultobj = NULL;
11153 wxString *arg1 = 0 ;
11154 wxString *arg2 = 0 ;
11155 int arg3 = (int) -1 ;
11156 wxImage *result;
11157 bool temp1 = false ;
11158 bool temp2 = false ;
11159 PyObject * obj0 = 0 ;
11160 PyObject * obj1 = 0 ;
11161 PyObject * obj2 = 0 ;
11162 char *kwnames[] = {
11163 (char *) "name",(char *) "mimetype",(char *) "index", NULL
11164 };
11165
11166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11167 {
11168 arg1 = wxString_in_helper(obj0);
11169 if (arg1 == NULL) SWIG_fail;
11170 temp1 = true;
11171 }
11172 {
11173 arg2 = wxString_in_helper(obj1);
11174 if (arg2 == NULL) SWIG_fail;
11175 temp2 = true;
11176 }
11177 if (obj2) {
11178 {
11179 arg3 = static_cast<int >(SWIG_As_int(obj2));
11180 if (SWIG_arg_fail(3)) SWIG_fail;
11181 }
11182 }
11183 {
11184 PyThreadState* __tstate = wxPyBeginAllowThreads();
11185 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11186
11187 wxPyEndAllowThreads(__tstate);
11188 if (PyErr_Occurred()) SWIG_fail;
11189 }
11190 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11191 {
11192 if (temp1)
11193 delete arg1;
11194 }
11195 {
11196 if (temp2)
11197 delete arg2;
11198 }
11199 return resultobj;
11200 fail:
11201 {
11202 if (temp1)
11203 delete arg1;
11204 }
11205 {
11206 if (temp2)
11207 delete arg2;
11208 }
11209 return NULL;
11210 }
11211
11212
11213 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
11214 PyObject *resultobj = NULL;
11215 wxInputStream *arg1 = 0 ;
11216 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11217 int arg3 = (int) -1 ;
11218 wxImage *result;
11219 wxPyInputStream *temp1 ;
11220 bool created1 ;
11221 PyObject * obj0 = 0 ;
11222 PyObject * obj1 = 0 ;
11223 PyObject * obj2 = 0 ;
11224 char *kwnames[] = {
11225 (char *) "stream",(char *) "type",(char *) "index", NULL
11226 };
11227
11228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
11229 {
11230 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11231 arg1 = temp1->m_wxis;
11232 created1 = false;
11233 } else {
11234 PyErr_Clear(); // clear the failure of the wxPyConvert above
11235 arg1 = wxPyCBInputStream_create(obj0, false);
11236 if (arg1 == NULL) {
11237 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11238 SWIG_fail;
11239 }
11240 created1 = true;
11241 }
11242 }
11243 if (obj1) {
11244 {
11245 arg2 = static_cast<long >(SWIG_As_long(obj1));
11246 if (SWIG_arg_fail(2)) SWIG_fail;
11247 }
11248 }
11249 if (obj2) {
11250 {
11251 arg3 = static_cast<int >(SWIG_As_int(obj2));
11252 if (SWIG_arg_fail(3)) SWIG_fail;
11253 }
11254 }
11255 {
11256 PyThreadState* __tstate = wxPyBeginAllowThreads();
11257 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
11258
11259 wxPyEndAllowThreads(__tstate);
11260 if (PyErr_Occurred()) SWIG_fail;
11261 }
11262 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11263 {
11264 if (created1) delete arg1;
11265 }
11266 return resultobj;
11267 fail:
11268 {
11269 if (created1) delete arg1;
11270 }
11271 return NULL;
11272 }
11273
11274
11275 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
11276 PyObject *resultobj = NULL;
11277 wxInputStream *arg1 = 0 ;
11278 wxString *arg2 = 0 ;
11279 int arg3 = (int) -1 ;
11280 wxImage *result;
11281 wxPyInputStream *temp1 ;
11282 bool created1 ;
11283 bool temp2 = false ;
11284 PyObject * obj0 = 0 ;
11285 PyObject * obj1 = 0 ;
11286 PyObject * obj2 = 0 ;
11287 char *kwnames[] = {
11288 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
11289 };
11290
11291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11292 {
11293 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11294 arg1 = temp1->m_wxis;
11295 created1 = false;
11296 } else {
11297 PyErr_Clear(); // clear the failure of the wxPyConvert above
11298 arg1 = wxPyCBInputStream_create(obj0, false);
11299 if (arg1 == NULL) {
11300 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11301 SWIG_fail;
11302 }
11303 created1 = true;
11304 }
11305 }
11306 {
11307 arg2 = wxString_in_helper(obj1);
11308 if (arg2 == NULL) SWIG_fail;
11309 temp2 = true;
11310 }
11311 if (obj2) {
11312 {
11313 arg3 = static_cast<int >(SWIG_As_int(obj2));
11314 if (SWIG_arg_fail(3)) SWIG_fail;
11315 }
11316 }
11317 {
11318 PyThreadState* __tstate = wxPyBeginAllowThreads();
11319 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
11320
11321 wxPyEndAllowThreads(__tstate);
11322 if (PyErr_Occurred()) SWIG_fail;
11323 }
11324 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11325 {
11326 if (created1) delete arg1;
11327 }
11328 {
11329 if (temp2)
11330 delete arg2;
11331 }
11332 return resultobj;
11333 fail:
11334 {
11335 if (created1) delete arg1;
11336 }
11337 {
11338 if (temp2)
11339 delete arg2;
11340 }
11341 return NULL;
11342 }
11343
11344
11345 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
11346 PyObject *resultobj = NULL;
11347 int arg1 = (int) 0 ;
11348 int arg2 = (int) 0 ;
11349 bool arg3 = (bool) true ;
11350 wxImage *result;
11351 PyObject * obj0 = 0 ;
11352 PyObject * obj1 = 0 ;
11353 PyObject * obj2 = 0 ;
11354 char *kwnames[] = {
11355 (char *) "width",(char *) "height",(char *) "clear", NULL
11356 };
11357
11358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
11359 if (obj0) {
11360 {
11361 arg1 = static_cast<int >(SWIG_As_int(obj0));
11362 if (SWIG_arg_fail(1)) SWIG_fail;
11363 }
11364 }
11365 if (obj1) {
11366 {
11367 arg2 = static_cast<int >(SWIG_As_int(obj1));
11368 if (SWIG_arg_fail(2)) SWIG_fail;
11369 }
11370 }
11371 if (obj2) {
11372 {
11373 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
11374 if (SWIG_arg_fail(3)) SWIG_fail;
11375 }
11376 }
11377 {
11378 PyThreadState* __tstate = wxPyBeginAllowThreads();
11379 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
11380
11381 wxPyEndAllowThreads(__tstate);
11382 if (PyErr_Occurred()) SWIG_fail;
11383 }
11384 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11385 return resultobj;
11386 fail:
11387 return NULL;
11388 }
11389
11390
11391 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
11392 PyObject *resultobj = NULL;
11393 wxBitmap *arg1 = 0 ;
11394 wxImage *result;
11395 PyObject * obj0 = 0 ;
11396 char *kwnames[] = {
11397 (char *) "bitmap", NULL
11398 };
11399
11400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
11401 {
11402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
11403 if (SWIG_arg_fail(1)) SWIG_fail;
11404 if (arg1 == NULL) {
11405 SWIG_null_ref("wxBitmap");
11406 }
11407 if (SWIG_arg_fail(1)) SWIG_fail;
11408 }
11409 {
11410 if (!wxPyCheckForApp()) SWIG_fail;
11411 PyThreadState* __tstate = wxPyBeginAllowThreads();
11412 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
11413
11414 wxPyEndAllowThreads(__tstate);
11415 if (PyErr_Occurred()) SWIG_fail;
11416 }
11417 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11418 return resultobj;
11419 fail:
11420 return NULL;
11421 }
11422
11423
11424 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
11425 PyObject *resultobj = NULL;
11426 int arg1 ;
11427 int arg2 ;
11428 buffer arg3 ;
11429 int arg4 ;
11430 wxImage *result;
11431 PyObject * obj0 = 0 ;
11432 PyObject * obj1 = 0 ;
11433 PyObject * obj2 = 0 ;
11434 char *kwnames[] = {
11435 (char *) "width",(char *) "height",(char *) "data", NULL
11436 };
11437
11438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
11439 {
11440 arg1 = static_cast<int >(SWIG_As_int(obj0));
11441 if (SWIG_arg_fail(1)) SWIG_fail;
11442 }
11443 {
11444 arg2 = static_cast<int >(SWIG_As_int(obj1));
11445 if (SWIG_arg_fail(2)) SWIG_fail;
11446 }
11447 {
11448 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11449 }
11450 {
11451 PyThreadState* __tstate = wxPyBeginAllowThreads();
11452 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
11453
11454 wxPyEndAllowThreads(__tstate);
11455 if (PyErr_Occurred()) SWIG_fail;
11456 }
11457 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11458 return resultobj;
11459 fail:
11460 return NULL;
11461 }
11462
11463
11464 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11465 PyObject *resultobj = NULL;
11466 int arg1 ;
11467 int arg2 ;
11468 buffer arg3 ;
11469 int arg4 ;
11470 buffer arg5 ;
11471 int arg6 ;
11472 wxImage *result;
11473 PyObject * obj0 = 0 ;
11474 PyObject * obj1 = 0 ;
11475 PyObject * obj2 = 0 ;
11476 PyObject * obj3 = 0 ;
11477 char *kwnames[] = {
11478 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
11479 };
11480
11481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11482 {
11483 arg1 = static_cast<int >(SWIG_As_int(obj0));
11484 if (SWIG_arg_fail(1)) SWIG_fail;
11485 }
11486 {
11487 arg2 = static_cast<int >(SWIG_As_int(obj1));
11488 if (SWIG_arg_fail(2)) SWIG_fail;
11489 }
11490 {
11491 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11492 }
11493 {
11494 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
11495 }
11496 {
11497 PyThreadState* __tstate = wxPyBeginAllowThreads();
11498 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
11499
11500 wxPyEndAllowThreads(__tstate);
11501 if (PyErr_Occurred()) SWIG_fail;
11502 }
11503 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11504 return resultobj;
11505 fail:
11506 return NULL;
11507 }
11508
11509
11510 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11511 PyObject *resultobj = NULL;
11512 wxImage *arg1 = (wxImage *) 0 ;
11513 int arg2 ;
11514 int arg3 ;
11515 bool arg4 = (bool) true ;
11516 PyObject * obj0 = 0 ;
11517 PyObject * obj1 = 0 ;
11518 PyObject * obj2 = 0 ;
11519 PyObject * obj3 = 0 ;
11520 char *kwnames[] = {
11521 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
11522 };
11523
11524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11526 if (SWIG_arg_fail(1)) SWIG_fail;
11527 {
11528 arg2 = static_cast<int >(SWIG_As_int(obj1));
11529 if (SWIG_arg_fail(2)) SWIG_fail;
11530 }
11531 {
11532 arg3 = static_cast<int >(SWIG_As_int(obj2));
11533 if (SWIG_arg_fail(3)) SWIG_fail;
11534 }
11535 if (obj3) {
11536 {
11537 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
11538 if (SWIG_arg_fail(4)) SWIG_fail;
11539 }
11540 }
11541 {
11542 PyThreadState* __tstate = wxPyBeginAllowThreads();
11543 (arg1)->Create(arg2,arg3,arg4);
11544
11545 wxPyEndAllowThreads(__tstate);
11546 if (PyErr_Occurred()) SWIG_fail;
11547 }
11548 Py_INCREF(Py_None); resultobj = Py_None;
11549 return resultobj;
11550 fail:
11551 return NULL;
11552 }
11553
11554
11555 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
11556 PyObject *resultobj = NULL;
11557 wxImage *arg1 = (wxImage *) 0 ;
11558 PyObject * obj0 = 0 ;
11559 char *kwnames[] = {
11560 (char *) "self", NULL
11561 };
11562
11563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
11564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11565 if (SWIG_arg_fail(1)) SWIG_fail;
11566 {
11567 PyThreadState* __tstate = wxPyBeginAllowThreads();
11568 (arg1)->Destroy();
11569
11570 wxPyEndAllowThreads(__tstate);
11571 if (PyErr_Occurred()) SWIG_fail;
11572 }
11573 Py_INCREF(Py_None); resultobj = Py_None;
11574 return resultobj;
11575 fail:
11576 return NULL;
11577 }
11578
11579
11580 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
11581 PyObject *resultobj = NULL;
11582 wxImage *arg1 = (wxImage *) 0 ;
11583 int arg2 ;
11584 int arg3 ;
11585 SwigValueWrapper<wxImage > result;
11586 PyObject * obj0 = 0 ;
11587 PyObject * obj1 = 0 ;
11588 PyObject * obj2 = 0 ;
11589 char *kwnames[] = {
11590 (char *) "self",(char *) "width",(char *) "height", NULL
11591 };
11592
11593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11595 if (SWIG_arg_fail(1)) SWIG_fail;
11596 {
11597 arg2 = static_cast<int >(SWIG_As_int(obj1));
11598 if (SWIG_arg_fail(2)) SWIG_fail;
11599 }
11600 {
11601 arg3 = static_cast<int >(SWIG_As_int(obj2));
11602 if (SWIG_arg_fail(3)) SWIG_fail;
11603 }
11604 {
11605 PyThreadState* __tstate = wxPyBeginAllowThreads();
11606 result = (arg1)->Scale(arg2,arg3);
11607
11608 wxPyEndAllowThreads(__tstate);
11609 if (PyErr_Occurred()) SWIG_fail;
11610 }
11611 {
11612 wxImage * resultptr;
11613 resultptr = new wxImage(static_cast<wxImage & >(result));
11614 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11615 }
11616 return resultobj;
11617 fail:
11618 return NULL;
11619 }
11620
11621
11622 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11623 PyObject *resultobj = NULL;
11624 wxImage *arg1 = (wxImage *) 0 ;
11625 int arg2 ;
11626 int arg3 ;
11627 SwigValueWrapper<wxImage > result;
11628 PyObject * obj0 = 0 ;
11629 PyObject * obj1 = 0 ;
11630 PyObject * obj2 = 0 ;
11631 char *kwnames[] = {
11632 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11633 };
11634
11635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11637 if (SWIG_arg_fail(1)) SWIG_fail;
11638 {
11639 arg2 = static_cast<int >(SWIG_As_int(obj1));
11640 if (SWIG_arg_fail(2)) SWIG_fail;
11641 }
11642 {
11643 arg3 = static_cast<int >(SWIG_As_int(obj2));
11644 if (SWIG_arg_fail(3)) SWIG_fail;
11645 }
11646 {
11647 PyThreadState* __tstate = wxPyBeginAllowThreads();
11648 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11649
11650 wxPyEndAllowThreads(__tstate);
11651 if (PyErr_Occurred()) SWIG_fail;
11652 }
11653 {
11654 wxImage * resultptr;
11655 resultptr = new wxImage(static_cast<wxImage & >(result));
11656 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11657 }
11658 return resultobj;
11659 fail:
11660 return NULL;
11661 }
11662
11663
11664 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11665 PyObject *resultobj = NULL;
11666 wxImage *arg1 = (wxImage *) 0 ;
11667 int arg2 ;
11668 int arg3 ;
11669 wxImage *result;
11670 PyObject * obj0 = 0 ;
11671 PyObject * obj1 = 0 ;
11672 PyObject * obj2 = 0 ;
11673 char *kwnames[] = {
11674 (char *) "self",(char *) "width",(char *) "height", NULL
11675 };
11676
11677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11679 if (SWIG_arg_fail(1)) SWIG_fail;
11680 {
11681 arg2 = static_cast<int >(SWIG_As_int(obj1));
11682 if (SWIG_arg_fail(2)) SWIG_fail;
11683 }
11684 {
11685 arg3 = static_cast<int >(SWIG_As_int(obj2));
11686 if (SWIG_arg_fail(3)) SWIG_fail;
11687 }
11688 {
11689 PyThreadState* __tstate = wxPyBeginAllowThreads();
11690 {
11691 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11692 result = (wxImage *) &_result_ref;
11693 }
11694
11695 wxPyEndAllowThreads(__tstate);
11696 if (PyErr_Occurred()) SWIG_fail;
11697 }
11698 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11699 return resultobj;
11700 fail:
11701 return NULL;
11702 }
11703
11704
11705 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11706 PyObject *resultobj = NULL;
11707 wxImage *arg1 = (wxImage *) 0 ;
11708 wxSize *arg2 = 0 ;
11709 wxPoint *arg3 = 0 ;
11710 int arg4 = (int) -1 ;
11711 int arg5 = (int) -1 ;
11712 int arg6 = (int) -1 ;
11713 wxImage *result;
11714 wxSize temp2 ;
11715 wxPoint temp3 ;
11716 PyObject * obj0 = 0 ;
11717 PyObject * obj1 = 0 ;
11718 PyObject * obj2 = 0 ;
11719 PyObject * obj3 = 0 ;
11720 PyObject * obj4 = 0 ;
11721 PyObject * obj5 = 0 ;
11722 char *kwnames[] = {
11723 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11724 };
11725
11726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11728 if (SWIG_arg_fail(1)) SWIG_fail;
11729 {
11730 arg2 = &temp2;
11731 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11732 }
11733 {
11734 arg3 = &temp3;
11735 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11736 }
11737 if (obj3) {
11738 {
11739 arg4 = static_cast<int >(SWIG_As_int(obj3));
11740 if (SWIG_arg_fail(4)) SWIG_fail;
11741 }
11742 }
11743 if (obj4) {
11744 {
11745 arg5 = static_cast<int >(SWIG_As_int(obj4));
11746 if (SWIG_arg_fail(5)) SWIG_fail;
11747 }
11748 }
11749 if (obj5) {
11750 {
11751 arg6 = static_cast<int >(SWIG_As_int(obj5));
11752 if (SWIG_arg_fail(6)) SWIG_fail;
11753 }
11754 }
11755 {
11756 PyThreadState* __tstate = wxPyBeginAllowThreads();
11757 {
11758 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11759 result = (wxImage *) &_result_ref;
11760 }
11761
11762 wxPyEndAllowThreads(__tstate);
11763 if (PyErr_Occurred()) SWIG_fail;
11764 }
11765 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11766 return resultobj;
11767 fail:
11768 return NULL;
11769 }
11770
11771
11772 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11773 PyObject *resultobj = NULL;
11774 wxImage *arg1 = (wxImage *) 0 ;
11775 int arg2 ;
11776 int arg3 ;
11777 byte arg4 ;
11778 byte arg5 ;
11779 byte arg6 ;
11780 PyObject * obj0 = 0 ;
11781 PyObject * obj1 = 0 ;
11782 PyObject * obj2 = 0 ;
11783 PyObject * obj3 = 0 ;
11784 PyObject * obj4 = 0 ;
11785 PyObject * obj5 = 0 ;
11786 char *kwnames[] = {
11787 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11788 };
11789
11790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11792 if (SWIG_arg_fail(1)) SWIG_fail;
11793 {
11794 arg2 = static_cast<int >(SWIG_As_int(obj1));
11795 if (SWIG_arg_fail(2)) SWIG_fail;
11796 }
11797 {
11798 arg3 = static_cast<int >(SWIG_As_int(obj2));
11799 if (SWIG_arg_fail(3)) SWIG_fail;
11800 }
11801 {
11802 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
11803 if (SWIG_arg_fail(4)) SWIG_fail;
11804 }
11805 {
11806 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
11807 if (SWIG_arg_fail(5)) SWIG_fail;
11808 }
11809 {
11810 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj5));
11811 if (SWIG_arg_fail(6)) SWIG_fail;
11812 }
11813 {
11814 PyThreadState* __tstate = wxPyBeginAllowThreads();
11815 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11816
11817 wxPyEndAllowThreads(__tstate);
11818 if (PyErr_Occurred()) SWIG_fail;
11819 }
11820 Py_INCREF(Py_None); resultobj = Py_None;
11821 return resultobj;
11822 fail:
11823 return NULL;
11824 }
11825
11826
11827 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11828 PyObject *resultobj = NULL;
11829 wxImage *arg1 = (wxImage *) 0 ;
11830 wxRect *arg2 = 0 ;
11831 byte arg3 ;
11832 byte arg4 ;
11833 byte arg5 ;
11834 wxRect temp2 ;
11835 PyObject * obj0 = 0 ;
11836 PyObject * obj1 = 0 ;
11837 PyObject * obj2 = 0 ;
11838 PyObject * obj3 = 0 ;
11839 PyObject * obj4 = 0 ;
11840 char *kwnames[] = {
11841 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11842 };
11843
11844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11846 if (SWIG_arg_fail(1)) SWIG_fail;
11847 {
11848 arg2 = &temp2;
11849 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11850 }
11851 {
11852 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
11853 if (SWIG_arg_fail(3)) SWIG_fail;
11854 }
11855 {
11856 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
11857 if (SWIG_arg_fail(4)) SWIG_fail;
11858 }
11859 {
11860 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
11861 if (SWIG_arg_fail(5)) SWIG_fail;
11862 }
11863 {
11864 PyThreadState* __tstate = wxPyBeginAllowThreads();
11865 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11866
11867 wxPyEndAllowThreads(__tstate);
11868 if (PyErr_Occurred()) SWIG_fail;
11869 }
11870 Py_INCREF(Py_None); resultobj = Py_None;
11871 return resultobj;
11872 fail:
11873 return NULL;
11874 }
11875
11876
11877 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11878 PyObject *resultobj = NULL;
11879 wxImage *arg1 = (wxImage *) 0 ;
11880 int arg2 ;
11881 int arg3 ;
11882 byte result;
11883 PyObject * obj0 = 0 ;
11884 PyObject * obj1 = 0 ;
11885 PyObject * obj2 = 0 ;
11886 char *kwnames[] = {
11887 (char *) "self",(char *) "x",(char *) "y", NULL
11888 };
11889
11890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11892 if (SWIG_arg_fail(1)) SWIG_fail;
11893 {
11894 arg2 = static_cast<int >(SWIG_As_int(obj1));
11895 if (SWIG_arg_fail(2)) SWIG_fail;
11896 }
11897 {
11898 arg3 = static_cast<int >(SWIG_As_int(obj2));
11899 if (SWIG_arg_fail(3)) SWIG_fail;
11900 }
11901 {
11902 PyThreadState* __tstate = wxPyBeginAllowThreads();
11903 result = (byte)(arg1)->GetRed(arg2,arg3);
11904
11905 wxPyEndAllowThreads(__tstate);
11906 if (PyErr_Occurred()) SWIG_fail;
11907 }
11908 {
11909 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
11910 }
11911 return resultobj;
11912 fail:
11913 return NULL;
11914 }
11915
11916
11917 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11918 PyObject *resultobj = NULL;
11919 wxImage *arg1 = (wxImage *) 0 ;
11920 int arg2 ;
11921 int arg3 ;
11922 byte result;
11923 PyObject * obj0 = 0 ;
11924 PyObject * obj1 = 0 ;
11925 PyObject * obj2 = 0 ;
11926 char *kwnames[] = {
11927 (char *) "self",(char *) "x",(char *) "y", NULL
11928 };
11929
11930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11932 if (SWIG_arg_fail(1)) SWIG_fail;
11933 {
11934 arg2 = static_cast<int >(SWIG_As_int(obj1));
11935 if (SWIG_arg_fail(2)) SWIG_fail;
11936 }
11937 {
11938 arg3 = static_cast<int >(SWIG_As_int(obj2));
11939 if (SWIG_arg_fail(3)) SWIG_fail;
11940 }
11941 {
11942 PyThreadState* __tstate = wxPyBeginAllowThreads();
11943 result = (byte)(arg1)->GetGreen(arg2,arg3);
11944
11945 wxPyEndAllowThreads(__tstate);
11946 if (PyErr_Occurred()) SWIG_fail;
11947 }
11948 {
11949 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
11950 }
11951 return resultobj;
11952 fail:
11953 return NULL;
11954 }
11955
11956
11957 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11958 PyObject *resultobj = NULL;
11959 wxImage *arg1 = (wxImage *) 0 ;
11960 int arg2 ;
11961 int arg3 ;
11962 byte result;
11963 PyObject * obj0 = 0 ;
11964 PyObject * obj1 = 0 ;
11965 PyObject * obj2 = 0 ;
11966 char *kwnames[] = {
11967 (char *) "self",(char *) "x",(char *) "y", NULL
11968 };
11969
11970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11972 if (SWIG_arg_fail(1)) SWIG_fail;
11973 {
11974 arg2 = static_cast<int >(SWIG_As_int(obj1));
11975 if (SWIG_arg_fail(2)) SWIG_fail;
11976 }
11977 {
11978 arg3 = static_cast<int >(SWIG_As_int(obj2));
11979 if (SWIG_arg_fail(3)) SWIG_fail;
11980 }
11981 {
11982 PyThreadState* __tstate = wxPyBeginAllowThreads();
11983 result = (byte)(arg1)->GetBlue(arg2,arg3);
11984
11985 wxPyEndAllowThreads(__tstate);
11986 if (PyErr_Occurred()) SWIG_fail;
11987 }
11988 {
11989 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
11990 }
11991 return resultobj;
11992 fail:
11993 return NULL;
11994 }
11995
11996
11997 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11998 PyObject *resultobj = NULL;
11999 wxImage *arg1 = (wxImage *) 0 ;
12000 int arg2 ;
12001 int arg3 ;
12002 byte arg4 ;
12003 PyObject * obj0 = 0 ;
12004 PyObject * obj1 = 0 ;
12005 PyObject * obj2 = 0 ;
12006 PyObject * obj3 = 0 ;
12007 char *kwnames[] = {
12008 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
12009 };
12010
12011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12013 if (SWIG_arg_fail(1)) SWIG_fail;
12014 {
12015 arg2 = static_cast<int >(SWIG_As_int(obj1));
12016 if (SWIG_arg_fail(2)) SWIG_fail;
12017 }
12018 {
12019 arg3 = static_cast<int >(SWIG_As_int(obj2));
12020 if (SWIG_arg_fail(3)) SWIG_fail;
12021 }
12022 {
12023 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12024 if (SWIG_arg_fail(4)) SWIG_fail;
12025 }
12026 {
12027 PyThreadState* __tstate = wxPyBeginAllowThreads();
12028 (arg1)->SetAlpha(arg2,arg3,arg4);
12029
12030 wxPyEndAllowThreads(__tstate);
12031 if (PyErr_Occurred()) SWIG_fail;
12032 }
12033 Py_INCREF(Py_None); resultobj = Py_None;
12034 return resultobj;
12035 fail:
12036 return NULL;
12037 }
12038
12039
12040 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12041 PyObject *resultobj = NULL;
12042 wxImage *arg1 = (wxImage *) 0 ;
12043 int arg2 ;
12044 int arg3 ;
12045 byte result;
12046 PyObject * obj0 = 0 ;
12047 PyObject * obj1 = 0 ;
12048 PyObject * obj2 = 0 ;
12049 char *kwnames[] = {
12050 (char *) "self",(char *) "x",(char *) "y", NULL
12051 };
12052
12053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
12054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12055 if (SWIG_arg_fail(1)) SWIG_fail;
12056 {
12057 arg2 = static_cast<int >(SWIG_As_int(obj1));
12058 if (SWIG_arg_fail(2)) SWIG_fail;
12059 }
12060 {
12061 arg3 = static_cast<int >(SWIG_As_int(obj2));
12062 if (SWIG_arg_fail(3)) SWIG_fail;
12063 }
12064 {
12065 PyThreadState* __tstate = wxPyBeginAllowThreads();
12066 result = (byte)(arg1)->GetAlpha(arg2,arg3);
12067
12068 wxPyEndAllowThreads(__tstate);
12069 if (PyErr_Occurred()) SWIG_fail;
12070 }
12071 {
12072 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
12073 }
12074 return resultobj;
12075 fail:
12076 return NULL;
12077 }
12078
12079
12080 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12081 PyObject *resultobj = NULL;
12082 wxImage *arg1 = (wxImage *) 0 ;
12083 bool result;
12084 PyObject * obj0 = 0 ;
12085 char *kwnames[] = {
12086 (char *) "self", NULL
12087 };
12088
12089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
12090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12091 if (SWIG_arg_fail(1)) SWIG_fail;
12092 {
12093 PyThreadState* __tstate = wxPyBeginAllowThreads();
12094 result = (bool)(arg1)->HasAlpha();
12095
12096 wxPyEndAllowThreads(__tstate);
12097 if (PyErr_Occurred()) SWIG_fail;
12098 }
12099 {
12100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12101 }
12102 return resultobj;
12103 fail:
12104 return NULL;
12105 }
12106
12107
12108 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12109 PyObject *resultobj = NULL;
12110 wxImage *arg1 = (wxImage *) 0 ;
12111 PyObject * obj0 = 0 ;
12112 char *kwnames[] = {
12113 (char *) "self", NULL
12114 };
12115
12116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
12117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12118 if (SWIG_arg_fail(1)) SWIG_fail;
12119 {
12120 PyThreadState* __tstate = wxPyBeginAllowThreads();
12121 (arg1)->InitAlpha();
12122
12123 wxPyEndAllowThreads(__tstate);
12124 if (PyErr_Occurred()) SWIG_fail;
12125 }
12126 Py_INCREF(Py_None); resultobj = Py_None;
12127 return resultobj;
12128 fail:
12129 return NULL;
12130 }
12131
12132
12133 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
12134 PyObject *resultobj = NULL;
12135 wxImage *arg1 = (wxImage *) 0 ;
12136 int arg2 ;
12137 int arg3 ;
12138 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12139 bool result;
12140 PyObject * obj0 = 0 ;
12141 PyObject * obj1 = 0 ;
12142 PyObject * obj2 = 0 ;
12143 PyObject * obj3 = 0 ;
12144 char *kwnames[] = {
12145 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
12146 };
12147
12148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12150 if (SWIG_arg_fail(1)) SWIG_fail;
12151 {
12152 arg2 = static_cast<int >(SWIG_As_int(obj1));
12153 if (SWIG_arg_fail(2)) SWIG_fail;
12154 }
12155 {
12156 arg3 = static_cast<int >(SWIG_As_int(obj2));
12157 if (SWIG_arg_fail(3)) SWIG_fail;
12158 }
12159 if (obj3) {
12160 {
12161 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12162 if (SWIG_arg_fail(4)) SWIG_fail;
12163 }
12164 }
12165 {
12166 PyThreadState* __tstate = wxPyBeginAllowThreads();
12167 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
12168
12169 wxPyEndAllowThreads(__tstate);
12170 if (PyErr_Occurred()) SWIG_fail;
12171 }
12172 {
12173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12174 }
12175 return resultobj;
12176 fail:
12177 return NULL;
12178 }
12179
12180
12181 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
12182 PyObject *resultobj = NULL;
12183 wxImage *arg1 = (wxImage *) 0 ;
12184 byte *arg2 = (byte *) 0 ;
12185 byte *arg3 = (byte *) 0 ;
12186 byte *arg4 = (byte *) 0 ;
12187 byte arg5 = (byte) 0 ;
12188 byte arg6 = (byte) 0 ;
12189 byte arg7 = (byte) 0 ;
12190 bool result;
12191 byte temp2 ;
12192 int res2 = 0 ;
12193 byte temp3 ;
12194 int res3 = 0 ;
12195 byte temp4 ;
12196 int res4 = 0 ;
12197 PyObject * obj0 = 0 ;
12198 PyObject * obj1 = 0 ;
12199 PyObject * obj2 = 0 ;
12200 PyObject * obj3 = 0 ;
12201 char *kwnames[] = {
12202 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12203 };
12204
12205 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12206 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12207 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12210 if (SWIG_arg_fail(1)) SWIG_fail;
12211 if (obj1) {
12212 {
12213 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12214 if (SWIG_arg_fail(5)) SWIG_fail;
12215 }
12216 }
12217 if (obj2) {
12218 {
12219 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12220 if (SWIG_arg_fail(6)) SWIG_fail;
12221 }
12222 }
12223 if (obj3) {
12224 {
12225 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12226 if (SWIG_arg_fail(7)) SWIG_fail;
12227 }
12228 }
12229 {
12230 PyThreadState* __tstate = wxPyBeginAllowThreads();
12231 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12232
12233 wxPyEndAllowThreads(__tstate);
12234 if (PyErr_Occurred()) SWIG_fail;
12235 }
12236 {
12237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12238 }
12239 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12240 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12241 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12242 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12243 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12244 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12245 return resultobj;
12246 fail:
12247 return NULL;
12248 }
12249
12250
12251 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
12252 PyObject *resultobj = NULL;
12253 wxImage *arg1 = (wxImage *) 0 ;
12254 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12255 bool result;
12256 PyObject * obj0 = 0 ;
12257 PyObject * obj1 = 0 ;
12258 char *kwnames[] = {
12259 (char *) "self",(char *) "threshold", NULL
12260 };
12261
12262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
12263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12264 if (SWIG_arg_fail(1)) SWIG_fail;
12265 if (obj1) {
12266 {
12267 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12268 if (SWIG_arg_fail(2)) SWIG_fail;
12269 }
12270 }
12271 {
12272 PyThreadState* __tstate = wxPyBeginAllowThreads();
12273 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
12274
12275 wxPyEndAllowThreads(__tstate);
12276 if (PyErr_Occurred()) SWIG_fail;
12277 }
12278 {
12279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12280 }
12281 return resultobj;
12282 fail:
12283 return NULL;
12284 }
12285
12286
12287 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12288 PyObject *resultobj = NULL;
12289 wxImage *arg1 = (wxImage *) 0 ;
12290 byte arg2 ;
12291 byte arg3 ;
12292 byte arg4 ;
12293 bool result;
12294 PyObject * obj0 = 0 ;
12295 PyObject * obj1 = 0 ;
12296 PyObject * obj2 = 0 ;
12297 PyObject * obj3 = 0 ;
12298 char *kwnames[] = {
12299 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12300 };
12301
12302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12304 if (SWIG_arg_fail(1)) SWIG_fail;
12305 {
12306 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12307 if (SWIG_arg_fail(2)) SWIG_fail;
12308 }
12309 {
12310 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12311 if (SWIG_arg_fail(3)) SWIG_fail;
12312 }
12313 {
12314 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12315 if (SWIG_arg_fail(4)) SWIG_fail;
12316 }
12317 {
12318 PyThreadState* __tstate = wxPyBeginAllowThreads();
12319 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
12320
12321 wxPyEndAllowThreads(__tstate);
12322 if (PyErr_Occurred()) SWIG_fail;
12323 }
12324 {
12325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12326 }
12327 return resultobj;
12328 fail:
12329 return NULL;
12330 }
12331
12332
12333 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
12334 PyObject *resultobj = NULL;
12335 wxImage *arg1 = (wxImage *) 0 ;
12336 wxImage *arg2 = 0 ;
12337 byte arg3 ;
12338 byte arg4 ;
12339 byte arg5 ;
12340 bool result;
12341 PyObject * obj0 = 0 ;
12342 PyObject * obj1 = 0 ;
12343 PyObject * obj2 = 0 ;
12344 PyObject * obj3 = 0 ;
12345 PyObject * obj4 = 0 ;
12346 char *kwnames[] = {
12347 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
12348 };
12349
12350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12352 if (SWIG_arg_fail(1)) SWIG_fail;
12353 {
12354 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12355 if (SWIG_arg_fail(2)) SWIG_fail;
12356 if (arg2 == NULL) {
12357 SWIG_null_ref("wxImage");
12358 }
12359 if (SWIG_arg_fail(2)) SWIG_fail;
12360 }
12361 {
12362 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12363 if (SWIG_arg_fail(3)) SWIG_fail;
12364 }
12365 {
12366 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12367 if (SWIG_arg_fail(4)) SWIG_fail;
12368 }
12369 {
12370 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
12371 if (SWIG_arg_fail(5)) SWIG_fail;
12372 }
12373 {
12374 PyThreadState* __tstate = wxPyBeginAllowThreads();
12375 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
12376
12377 wxPyEndAllowThreads(__tstate);
12378 if (PyErr_Occurred()) SWIG_fail;
12379 }
12380 {
12381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12382 }
12383 return resultobj;
12384 fail:
12385 return NULL;
12386 }
12387
12388
12389 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
12390 PyObject *resultobj = NULL;
12391 wxString *arg1 = 0 ;
12392 bool result;
12393 bool temp1 = false ;
12394 PyObject * obj0 = 0 ;
12395 char *kwnames[] = {
12396 (char *) "filename", NULL
12397 };
12398
12399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
12400 {
12401 arg1 = wxString_in_helper(obj0);
12402 if (arg1 == NULL) SWIG_fail;
12403 temp1 = true;
12404 }
12405 {
12406 PyThreadState* __tstate = wxPyBeginAllowThreads();
12407 result = (bool)wxImage::CanRead((wxString const &)*arg1);
12408
12409 wxPyEndAllowThreads(__tstate);
12410 if (PyErr_Occurred()) SWIG_fail;
12411 }
12412 {
12413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12414 }
12415 {
12416 if (temp1)
12417 delete arg1;
12418 }
12419 return resultobj;
12420 fail:
12421 {
12422 if (temp1)
12423 delete arg1;
12424 }
12425 return NULL;
12426 }
12427
12428
12429 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
12430 PyObject *resultobj = NULL;
12431 wxString *arg1 = 0 ;
12432 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12433 int result;
12434 bool temp1 = false ;
12435 PyObject * obj0 = 0 ;
12436 PyObject * obj1 = 0 ;
12437 char *kwnames[] = {
12438 (char *) "filename",(char *) "type", NULL
12439 };
12440
12441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
12442 {
12443 arg1 = wxString_in_helper(obj0);
12444 if (arg1 == NULL) SWIG_fail;
12445 temp1 = true;
12446 }
12447 if (obj1) {
12448 {
12449 arg2 = static_cast<long >(SWIG_As_long(obj1));
12450 if (SWIG_arg_fail(2)) SWIG_fail;
12451 }
12452 }
12453 {
12454 PyThreadState* __tstate = wxPyBeginAllowThreads();
12455 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
12456
12457 wxPyEndAllowThreads(__tstate);
12458 if (PyErr_Occurred()) SWIG_fail;
12459 }
12460 {
12461 resultobj = SWIG_From_int(static_cast<int >(result));
12462 }
12463 {
12464 if (temp1)
12465 delete arg1;
12466 }
12467 return resultobj;
12468 fail:
12469 {
12470 if (temp1)
12471 delete arg1;
12472 }
12473 return NULL;
12474 }
12475
12476
12477 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
12478 PyObject *resultobj = NULL;
12479 wxImage *arg1 = (wxImage *) 0 ;
12480 wxString *arg2 = 0 ;
12481 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12482 int arg4 = (int) -1 ;
12483 bool result;
12484 bool temp2 = false ;
12485 PyObject * obj0 = 0 ;
12486 PyObject * obj1 = 0 ;
12487 PyObject * obj2 = 0 ;
12488 PyObject * obj3 = 0 ;
12489 char *kwnames[] = {
12490 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
12491 };
12492
12493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12495 if (SWIG_arg_fail(1)) SWIG_fail;
12496 {
12497 arg2 = wxString_in_helper(obj1);
12498 if (arg2 == NULL) SWIG_fail;
12499 temp2 = true;
12500 }
12501 if (obj2) {
12502 {
12503 arg3 = static_cast<long >(SWIG_As_long(obj2));
12504 if (SWIG_arg_fail(3)) SWIG_fail;
12505 }
12506 }
12507 if (obj3) {
12508 {
12509 arg4 = static_cast<int >(SWIG_As_int(obj3));
12510 if (SWIG_arg_fail(4)) SWIG_fail;
12511 }
12512 }
12513 {
12514 PyThreadState* __tstate = wxPyBeginAllowThreads();
12515 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
12516
12517 wxPyEndAllowThreads(__tstate);
12518 if (PyErr_Occurred()) SWIG_fail;
12519 }
12520 {
12521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12522 }
12523 {
12524 if (temp2)
12525 delete arg2;
12526 }
12527 return resultobj;
12528 fail:
12529 {
12530 if (temp2)
12531 delete arg2;
12532 }
12533 return NULL;
12534 }
12535
12536
12537 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12538 PyObject *resultobj = NULL;
12539 wxImage *arg1 = (wxImage *) 0 ;
12540 wxString *arg2 = 0 ;
12541 wxString *arg3 = 0 ;
12542 int arg4 = (int) -1 ;
12543 bool result;
12544 bool temp2 = false ;
12545 bool temp3 = false ;
12546 PyObject * obj0 = 0 ;
12547 PyObject * obj1 = 0 ;
12548 PyObject * obj2 = 0 ;
12549 PyObject * obj3 = 0 ;
12550 char *kwnames[] = {
12551 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
12552 };
12553
12554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12556 if (SWIG_arg_fail(1)) SWIG_fail;
12557 {
12558 arg2 = wxString_in_helper(obj1);
12559 if (arg2 == NULL) SWIG_fail;
12560 temp2 = true;
12561 }
12562 {
12563 arg3 = wxString_in_helper(obj2);
12564 if (arg3 == NULL) SWIG_fail;
12565 temp3 = true;
12566 }
12567 if (obj3) {
12568 {
12569 arg4 = static_cast<int >(SWIG_As_int(obj3));
12570 if (SWIG_arg_fail(4)) SWIG_fail;
12571 }
12572 }
12573 {
12574 PyThreadState* __tstate = wxPyBeginAllowThreads();
12575 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
12576
12577 wxPyEndAllowThreads(__tstate);
12578 if (PyErr_Occurred()) SWIG_fail;
12579 }
12580 {
12581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12582 }
12583 {
12584 if (temp2)
12585 delete arg2;
12586 }
12587 {
12588 if (temp3)
12589 delete arg3;
12590 }
12591 return resultobj;
12592 fail:
12593 {
12594 if (temp2)
12595 delete arg2;
12596 }
12597 {
12598 if (temp3)
12599 delete arg3;
12600 }
12601 return NULL;
12602 }
12603
12604
12605 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12606 PyObject *resultobj = NULL;
12607 wxImage *arg1 = (wxImage *) 0 ;
12608 wxString *arg2 = 0 ;
12609 int arg3 ;
12610 bool result;
12611 bool temp2 = false ;
12612 PyObject * obj0 = 0 ;
12613 PyObject * obj1 = 0 ;
12614 PyObject * obj2 = 0 ;
12615 char *kwnames[] = {
12616 (char *) "self",(char *) "name",(char *) "type", NULL
12617 };
12618
12619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12621 if (SWIG_arg_fail(1)) SWIG_fail;
12622 {
12623 arg2 = wxString_in_helper(obj1);
12624 if (arg2 == NULL) SWIG_fail;
12625 temp2 = true;
12626 }
12627 {
12628 arg3 = static_cast<int >(SWIG_As_int(obj2));
12629 if (SWIG_arg_fail(3)) SWIG_fail;
12630 }
12631 {
12632 PyThreadState* __tstate = wxPyBeginAllowThreads();
12633 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12634
12635 wxPyEndAllowThreads(__tstate);
12636 if (PyErr_Occurred()) SWIG_fail;
12637 }
12638 {
12639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12640 }
12641 {
12642 if (temp2)
12643 delete arg2;
12644 }
12645 return resultobj;
12646 fail:
12647 {
12648 if (temp2)
12649 delete arg2;
12650 }
12651 return NULL;
12652 }
12653
12654
12655 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12656 PyObject *resultobj = NULL;
12657 wxImage *arg1 = (wxImage *) 0 ;
12658 wxString *arg2 = 0 ;
12659 wxString *arg3 = 0 ;
12660 bool result;
12661 bool temp2 = false ;
12662 bool temp3 = false ;
12663 PyObject * obj0 = 0 ;
12664 PyObject * obj1 = 0 ;
12665 PyObject * obj2 = 0 ;
12666 char *kwnames[] = {
12667 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12668 };
12669
12670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12672 if (SWIG_arg_fail(1)) SWIG_fail;
12673 {
12674 arg2 = wxString_in_helper(obj1);
12675 if (arg2 == NULL) SWIG_fail;
12676 temp2 = true;
12677 }
12678 {
12679 arg3 = wxString_in_helper(obj2);
12680 if (arg3 == NULL) SWIG_fail;
12681 temp3 = true;
12682 }
12683 {
12684 PyThreadState* __tstate = wxPyBeginAllowThreads();
12685 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12686
12687 wxPyEndAllowThreads(__tstate);
12688 if (PyErr_Occurred()) SWIG_fail;
12689 }
12690 {
12691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12692 }
12693 {
12694 if (temp2)
12695 delete arg2;
12696 }
12697 {
12698 if (temp3)
12699 delete arg3;
12700 }
12701 return resultobj;
12702 fail:
12703 {
12704 if (temp2)
12705 delete arg2;
12706 }
12707 {
12708 if (temp3)
12709 delete arg3;
12710 }
12711 return NULL;
12712 }
12713
12714
12715 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12716 PyObject *resultobj = NULL;
12717 wxInputStream *arg1 = 0 ;
12718 bool result;
12719 wxPyInputStream *temp1 ;
12720 bool created1 ;
12721 PyObject * obj0 = 0 ;
12722 char *kwnames[] = {
12723 (char *) "stream", NULL
12724 };
12725
12726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12727 {
12728 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12729 arg1 = temp1->m_wxis;
12730 created1 = false;
12731 } else {
12732 PyErr_Clear(); // clear the failure of the wxPyConvert above
12733 arg1 = wxPyCBInputStream_create(obj0, false);
12734 if (arg1 == NULL) {
12735 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12736 SWIG_fail;
12737 }
12738 created1 = true;
12739 }
12740 }
12741 {
12742 PyThreadState* __tstate = wxPyBeginAllowThreads();
12743 result = (bool)wxImage::CanRead(*arg1);
12744
12745 wxPyEndAllowThreads(__tstate);
12746 if (PyErr_Occurred()) SWIG_fail;
12747 }
12748 {
12749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12750 }
12751 {
12752 if (created1) delete arg1;
12753 }
12754 return resultobj;
12755 fail:
12756 {
12757 if (created1) delete arg1;
12758 }
12759 return NULL;
12760 }
12761
12762
12763 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12764 PyObject *resultobj = NULL;
12765 wxImage *arg1 = (wxImage *) 0 ;
12766 wxInputStream *arg2 = 0 ;
12767 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12768 int arg4 = (int) -1 ;
12769 bool result;
12770 wxPyInputStream *temp2 ;
12771 bool created2 ;
12772 PyObject * obj0 = 0 ;
12773 PyObject * obj1 = 0 ;
12774 PyObject * obj2 = 0 ;
12775 PyObject * obj3 = 0 ;
12776 char *kwnames[] = {
12777 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12778 };
12779
12780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12782 if (SWIG_arg_fail(1)) SWIG_fail;
12783 {
12784 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12785 arg2 = temp2->m_wxis;
12786 created2 = false;
12787 } else {
12788 PyErr_Clear(); // clear the failure of the wxPyConvert above
12789 arg2 = wxPyCBInputStream_create(obj1, false);
12790 if (arg2 == NULL) {
12791 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12792 SWIG_fail;
12793 }
12794 created2 = true;
12795 }
12796 }
12797 if (obj2) {
12798 {
12799 arg3 = static_cast<long >(SWIG_As_long(obj2));
12800 if (SWIG_arg_fail(3)) SWIG_fail;
12801 }
12802 }
12803 if (obj3) {
12804 {
12805 arg4 = static_cast<int >(SWIG_As_int(obj3));
12806 if (SWIG_arg_fail(4)) SWIG_fail;
12807 }
12808 }
12809 {
12810 PyThreadState* __tstate = wxPyBeginAllowThreads();
12811 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12812
12813 wxPyEndAllowThreads(__tstate);
12814 if (PyErr_Occurred()) SWIG_fail;
12815 }
12816 {
12817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12818 }
12819 {
12820 if (created2) delete arg2;
12821 }
12822 return resultobj;
12823 fail:
12824 {
12825 if (created2) delete arg2;
12826 }
12827 return NULL;
12828 }
12829
12830
12831 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12832 PyObject *resultobj = NULL;
12833 wxImage *arg1 = (wxImage *) 0 ;
12834 wxInputStream *arg2 = 0 ;
12835 wxString *arg3 = 0 ;
12836 int arg4 = (int) -1 ;
12837 bool result;
12838 wxPyInputStream *temp2 ;
12839 bool created2 ;
12840 bool temp3 = false ;
12841 PyObject * obj0 = 0 ;
12842 PyObject * obj1 = 0 ;
12843 PyObject * obj2 = 0 ;
12844 PyObject * obj3 = 0 ;
12845 char *kwnames[] = {
12846 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12847 };
12848
12849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12851 if (SWIG_arg_fail(1)) SWIG_fail;
12852 {
12853 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12854 arg2 = temp2->m_wxis;
12855 created2 = false;
12856 } else {
12857 PyErr_Clear(); // clear the failure of the wxPyConvert above
12858 arg2 = wxPyCBInputStream_create(obj1, false);
12859 if (arg2 == NULL) {
12860 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12861 SWIG_fail;
12862 }
12863 created2 = true;
12864 }
12865 }
12866 {
12867 arg3 = wxString_in_helper(obj2);
12868 if (arg3 == NULL) SWIG_fail;
12869 temp3 = true;
12870 }
12871 if (obj3) {
12872 {
12873 arg4 = static_cast<int >(SWIG_As_int(obj3));
12874 if (SWIG_arg_fail(4)) SWIG_fail;
12875 }
12876 }
12877 {
12878 PyThreadState* __tstate = wxPyBeginAllowThreads();
12879 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12880
12881 wxPyEndAllowThreads(__tstate);
12882 if (PyErr_Occurred()) SWIG_fail;
12883 }
12884 {
12885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12886 }
12887 {
12888 if (created2) delete arg2;
12889 }
12890 {
12891 if (temp3)
12892 delete arg3;
12893 }
12894 return resultobj;
12895 fail:
12896 {
12897 if (created2) delete arg2;
12898 }
12899 {
12900 if (temp3)
12901 delete arg3;
12902 }
12903 return NULL;
12904 }
12905
12906
12907 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12908 PyObject *resultobj = NULL;
12909 wxImage *arg1 = (wxImage *) 0 ;
12910 bool result;
12911 PyObject * obj0 = 0 ;
12912 char *kwnames[] = {
12913 (char *) "self", NULL
12914 };
12915
12916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12918 if (SWIG_arg_fail(1)) SWIG_fail;
12919 {
12920 PyThreadState* __tstate = wxPyBeginAllowThreads();
12921 result = (bool)(arg1)->Ok();
12922
12923 wxPyEndAllowThreads(__tstate);
12924 if (PyErr_Occurred()) SWIG_fail;
12925 }
12926 {
12927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12928 }
12929 return resultobj;
12930 fail:
12931 return NULL;
12932 }
12933
12934
12935 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12936 PyObject *resultobj = NULL;
12937 wxImage *arg1 = (wxImage *) 0 ;
12938 int result;
12939 PyObject * obj0 = 0 ;
12940 char *kwnames[] = {
12941 (char *) "self", NULL
12942 };
12943
12944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12946 if (SWIG_arg_fail(1)) SWIG_fail;
12947 {
12948 PyThreadState* __tstate = wxPyBeginAllowThreads();
12949 result = (int)(arg1)->GetWidth();
12950
12951 wxPyEndAllowThreads(__tstate);
12952 if (PyErr_Occurred()) SWIG_fail;
12953 }
12954 {
12955 resultobj = SWIG_From_int(static_cast<int >(result));
12956 }
12957 return resultobj;
12958 fail:
12959 return NULL;
12960 }
12961
12962
12963 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12964 PyObject *resultobj = NULL;
12965 wxImage *arg1 = (wxImage *) 0 ;
12966 int result;
12967 PyObject * obj0 = 0 ;
12968 char *kwnames[] = {
12969 (char *) "self", NULL
12970 };
12971
12972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12974 if (SWIG_arg_fail(1)) SWIG_fail;
12975 {
12976 PyThreadState* __tstate = wxPyBeginAllowThreads();
12977 result = (int)(arg1)->GetHeight();
12978
12979 wxPyEndAllowThreads(__tstate);
12980 if (PyErr_Occurred()) SWIG_fail;
12981 }
12982 {
12983 resultobj = SWIG_From_int(static_cast<int >(result));
12984 }
12985 return resultobj;
12986 fail:
12987 return NULL;
12988 }
12989
12990
12991 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12992 PyObject *resultobj = NULL;
12993 wxImage *arg1 = (wxImage *) 0 ;
12994 wxSize result;
12995 PyObject * obj0 = 0 ;
12996 char *kwnames[] = {
12997 (char *) "self", NULL
12998 };
12999
13000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
13001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13002 if (SWIG_arg_fail(1)) SWIG_fail;
13003 {
13004 PyThreadState* __tstate = wxPyBeginAllowThreads();
13005 result = wxImage_GetSize(arg1);
13006
13007 wxPyEndAllowThreads(__tstate);
13008 if (PyErr_Occurred()) SWIG_fail;
13009 }
13010 {
13011 wxSize * resultptr;
13012 resultptr = new wxSize(static_cast<wxSize & >(result));
13013 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
13014 }
13015 return resultobj;
13016 fail:
13017 return NULL;
13018 }
13019
13020
13021 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
13022 PyObject *resultobj = NULL;
13023 wxImage *arg1 = (wxImage *) 0 ;
13024 wxRect *arg2 = 0 ;
13025 SwigValueWrapper<wxImage > result;
13026 wxRect temp2 ;
13027 PyObject * obj0 = 0 ;
13028 PyObject * obj1 = 0 ;
13029 char *kwnames[] = {
13030 (char *) "self",(char *) "rect", NULL
13031 };
13032
13033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
13034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13035 if (SWIG_arg_fail(1)) SWIG_fail;
13036 {
13037 arg2 = &temp2;
13038 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13039 }
13040 {
13041 PyThreadState* __tstate = wxPyBeginAllowThreads();
13042 result = (arg1)->GetSubImage((wxRect const &)*arg2);
13043
13044 wxPyEndAllowThreads(__tstate);
13045 if (PyErr_Occurred()) SWIG_fail;
13046 }
13047 {
13048 wxImage * resultptr;
13049 resultptr = new wxImage(static_cast<wxImage & >(result));
13050 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13051 }
13052 return resultobj;
13053 fail:
13054 return NULL;
13055 }
13056
13057
13058 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
13059 PyObject *resultobj = NULL;
13060 wxImage *arg1 = (wxImage *) 0 ;
13061 wxSize *arg2 = 0 ;
13062 wxPoint *arg3 = 0 ;
13063 int arg4 = (int) -1 ;
13064 int arg5 = (int) -1 ;
13065 int arg6 = (int) -1 ;
13066 SwigValueWrapper<wxImage > result;
13067 wxSize temp2 ;
13068 wxPoint temp3 ;
13069 PyObject * obj0 = 0 ;
13070 PyObject * obj1 = 0 ;
13071 PyObject * obj2 = 0 ;
13072 PyObject * obj3 = 0 ;
13073 PyObject * obj4 = 0 ;
13074 PyObject * obj5 = 0 ;
13075 char *kwnames[] = {
13076 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13077 };
13078
13079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13081 if (SWIG_arg_fail(1)) SWIG_fail;
13082 {
13083 arg2 = &temp2;
13084 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13085 }
13086 {
13087 arg3 = &temp3;
13088 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13089 }
13090 if (obj3) {
13091 {
13092 arg4 = static_cast<int >(SWIG_As_int(obj3));
13093 if (SWIG_arg_fail(4)) SWIG_fail;
13094 }
13095 }
13096 if (obj4) {
13097 {
13098 arg5 = static_cast<int >(SWIG_As_int(obj4));
13099 if (SWIG_arg_fail(5)) SWIG_fail;
13100 }
13101 }
13102 if (obj5) {
13103 {
13104 arg6 = static_cast<int >(SWIG_As_int(obj5));
13105 if (SWIG_arg_fail(6)) SWIG_fail;
13106 }
13107 }
13108 {
13109 PyThreadState* __tstate = wxPyBeginAllowThreads();
13110 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13111
13112 wxPyEndAllowThreads(__tstate);
13113 if (PyErr_Occurred()) SWIG_fail;
13114 }
13115 {
13116 wxImage * resultptr;
13117 resultptr = new wxImage(static_cast<wxImage & >(result));
13118 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13119 }
13120 return resultobj;
13121 fail:
13122 return NULL;
13123 }
13124
13125
13126 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
13127 PyObject *resultobj = NULL;
13128 wxImage *arg1 = (wxImage *) 0 ;
13129 SwigValueWrapper<wxImage > result;
13130 PyObject * obj0 = 0 ;
13131 char *kwnames[] = {
13132 (char *) "self", NULL
13133 };
13134
13135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
13136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13137 if (SWIG_arg_fail(1)) SWIG_fail;
13138 {
13139 PyThreadState* __tstate = wxPyBeginAllowThreads();
13140 result = (arg1)->Copy();
13141
13142 wxPyEndAllowThreads(__tstate);
13143 if (PyErr_Occurred()) SWIG_fail;
13144 }
13145 {
13146 wxImage * resultptr;
13147 resultptr = new wxImage(static_cast<wxImage & >(result));
13148 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13149 }
13150 return resultobj;
13151 fail:
13152 return NULL;
13153 }
13154
13155
13156 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
13157 PyObject *resultobj = NULL;
13158 wxImage *arg1 = (wxImage *) 0 ;
13159 wxImage *arg2 = 0 ;
13160 int arg3 ;
13161 int arg4 ;
13162 PyObject * obj0 = 0 ;
13163 PyObject * obj1 = 0 ;
13164 PyObject * obj2 = 0 ;
13165 PyObject * obj3 = 0 ;
13166 char *kwnames[] = {
13167 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
13168 };
13169
13170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13172 if (SWIG_arg_fail(1)) SWIG_fail;
13173 {
13174 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13175 if (SWIG_arg_fail(2)) SWIG_fail;
13176 if (arg2 == NULL) {
13177 SWIG_null_ref("wxImage");
13178 }
13179 if (SWIG_arg_fail(2)) SWIG_fail;
13180 }
13181 {
13182 arg3 = static_cast<int >(SWIG_As_int(obj2));
13183 if (SWIG_arg_fail(3)) SWIG_fail;
13184 }
13185 {
13186 arg4 = static_cast<int >(SWIG_As_int(obj3));
13187 if (SWIG_arg_fail(4)) SWIG_fail;
13188 }
13189 {
13190 PyThreadState* __tstate = wxPyBeginAllowThreads();
13191 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
13192
13193 wxPyEndAllowThreads(__tstate);
13194 if (PyErr_Occurred()) SWIG_fail;
13195 }
13196 Py_INCREF(Py_None); resultobj = Py_None;
13197 return resultobj;
13198 fail:
13199 return NULL;
13200 }
13201
13202
13203 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
13204 PyObject *resultobj = NULL;
13205 wxImage *arg1 = (wxImage *) 0 ;
13206 PyObject *result;
13207 PyObject * obj0 = 0 ;
13208 char *kwnames[] = {
13209 (char *) "self", NULL
13210 };
13211
13212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
13213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13214 if (SWIG_arg_fail(1)) SWIG_fail;
13215 {
13216 PyThreadState* __tstate = wxPyBeginAllowThreads();
13217 result = (PyObject *)wxImage_GetData(arg1);
13218
13219 wxPyEndAllowThreads(__tstate);
13220 if (PyErr_Occurred()) SWIG_fail;
13221 }
13222 resultobj = result;
13223 return resultobj;
13224 fail:
13225 return NULL;
13226 }
13227
13228
13229 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
13230 PyObject *resultobj = NULL;
13231 wxImage *arg1 = (wxImage *) 0 ;
13232 buffer arg2 ;
13233 int arg3 ;
13234 PyObject * obj0 = 0 ;
13235 PyObject * obj1 = 0 ;
13236 char *kwnames[] = {
13237 (char *) "self",(char *) "data", NULL
13238 };
13239
13240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
13241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13242 if (SWIG_arg_fail(1)) SWIG_fail;
13243 {
13244 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13245 }
13246 {
13247 PyThreadState* __tstate = wxPyBeginAllowThreads();
13248 wxImage_SetData(arg1,arg2,arg3);
13249
13250 wxPyEndAllowThreads(__tstate);
13251 if (PyErr_Occurred()) SWIG_fail;
13252 }
13253 Py_INCREF(Py_None); resultobj = Py_None;
13254 return resultobj;
13255 fail:
13256 return NULL;
13257 }
13258
13259
13260 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13261 PyObject *resultobj = NULL;
13262 wxImage *arg1 = (wxImage *) 0 ;
13263 PyObject *result;
13264 PyObject * obj0 = 0 ;
13265 char *kwnames[] = {
13266 (char *) "self", NULL
13267 };
13268
13269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
13270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13271 if (SWIG_arg_fail(1)) SWIG_fail;
13272 {
13273 PyThreadState* __tstate = wxPyBeginAllowThreads();
13274 result = (PyObject *)wxImage_GetDataBuffer(arg1);
13275
13276 wxPyEndAllowThreads(__tstate);
13277 if (PyErr_Occurred()) SWIG_fail;
13278 }
13279 resultobj = result;
13280 return resultobj;
13281 fail:
13282 return NULL;
13283 }
13284
13285
13286 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13287 PyObject *resultobj = NULL;
13288 wxImage *arg1 = (wxImage *) 0 ;
13289 buffer arg2 ;
13290 int arg3 ;
13291 PyObject * obj0 = 0 ;
13292 PyObject * obj1 = 0 ;
13293 char *kwnames[] = {
13294 (char *) "self",(char *) "data", NULL
13295 };
13296
13297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
13298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13299 if (SWIG_arg_fail(1)) SWIG_fail;
13300 {
13301 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13302 }
13303 {
13304 PyThreadState* __tstate = wxPyBeginAllowThreads();
13305 wxImage_SetDataBuffer(arg1,arg2,arg3);
13306
13307 wxPyEndAllowThreads(__tstate);
13308 if (PyErr_Occurred()) SWIG_fail;
13309 }
13310 Py_INCREF(Py_None); resultobj = Py_None;
13311 return resultobj;
13312 fail:
13313 return NULL;
13314 }
13315
13316
13317 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13318 PyObject *resultobj = NULL;
13319 wxImage *arg1 = (wxImage *) 0 ;
13320 PyObject *result;
13321 PyObject * obj0 = 0 ;
13322 char *kwnames[] = {
13323 (char *) "self", NULL
13324 };
13325
13326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
13327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13328 if (SWIG_arg_fail(1)) SWIG_fail;
13329 {
13330 PyThreadState* __tstate = wxPyBeginAllowThreads();
13331 result = (PyObject *)wxImage_GetAlphaData(arg1);
13332
13333 wxPyEndAllowThreads(__tstate);
13334 if (PyErr_Occurred()) SWIG_fail;
13335 }
13336 resultobj = result;
13337 return resultobj;
13338 fail:
13339 return NULL;
13340 }
13341
13342
13343 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13344 PyObject *resultobj = NULL;
13345 wxImage *arg1 = (wxImage *) 0 ;
13346 buffer arg2 ;
13347 int arg3 ;
13348 PyObject * obj0 = 0 ;
13349 PyObject * obj1 = 0 ;
13350 char *kwnames[] = {
13351 (char *) "self",(char *) "alpha", NULL
13352 };
13353
13354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
13355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13356 if (SWIG_arg_fail(1)) SWIG_fail;
13357 {
13358 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13359 }
13360 {
13361 PyThreadState* __tstate = wxPyBeginAllowThreads();
13362 wxImage_SetAlphaData(arg1,arg2,arg3);
13363
13364 wxPyEndAllowThreads(__tstate);
13365 if (PyErr_Occurred()) SWIG_fail;
13366 }
13367 Py_INCREF(Py_None); resultobj = Py_None;
13368 return resultobj;
13369 fail:
13370 return NULL;
13371 }
13372
13373
13374 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13375 PyObject *resultobj = NULL;
13376 wxImage *arg1 = (wxImage *) 0 ;
13377 PyObject *result;
13378 PyObject * obj0 = 0 ;
13379 char *kwnames[] = {
13380 (char *) "self", NULL
13381 };
13382
13383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
13384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13385 if (SWIG_arg_fail(1)) SWIG_fail;
13386 {
13387 PyThreadState* __tstate = wxPyBeginAllowThreads();
13388 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
13389
13390 wxPyEndAllowThreads(__tstate);
13391 if (PyErr_Occurred()) SWIG_fail;
13392 }
13393 resultobj = result;
13394 return resultobj;
13395 fail:
13396 return NULL;
13397 }
13398
13399
13400 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13401 PyObject *resultobj = NULL;
13402 wxImage *arg1 = (wxImage *) 0 ;
13403 buffer arg2 ;
13404 int arg3 ;
13405 PyObject * obj0 = 0 ;
13406 PyObject * obj1 = 0 ;
13407 char *kwnames[] = {
13408 (char *) "self",(char *) "alpha", NULL
13409 };
13410
13411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
13412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13413 if (SWIG_arg_fail(1)) SWIG_fail;
13414 {
13415 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13416 }
13417 {
13418 PyThreadState* __tstate = wxPyBeginAllowThreads();
13419 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
13420
13421 wxPyEndAllowThreads(__tstate);
13422 if (PyErr_Occurred()) SWIG_fail;
13423 }
13424 Py_INCREF(Py_None); resultobj = Py_None;
13425 return resultobj;
13426 fail:
13427 return NULL;
13428 }
13429
13430
13431 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13432 PyObject *resultobj = NULL;
13433 wxImage *arg1 = (wxImage *) 0 ;
13434 byte arg2 ;
13435 byte arg3 ;
13436 byte arg4 ;
13437 PyObject * obj0 = 0 ;
13438 PyObject * obj1 = 0 ;
13439 PyObject * obj2 = 0 ;
13440 PyObject * obj3 = 0 ;
13441 char *kwnames[] = {
13442 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13443 };
13444
13445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13447 if (SWIG_arg_fail(1)) SWIG_fail;
13448 {
13449 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13450 if (SWIG_arg_fail(2)) SWIG_fail;
13451 }
13452 {
13453 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13454 if (SWIG_arg_fail(3)) SWIG_fail;
13455 }
13456 {
13457 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13458 if (SWIG_arg_fail(4)) SWIG_fail;
13459 }
13460 {
13461 PyThreadState* __tstate = wxPyBeginAllowThreads();
13462 (arg1)->SetMaskColour(arg2,arg3,arg4);
13463
13464 wxPyEndAllowThreads(__tstate);
13465 if (PyErr_Occurred()) SWIG_fail;
13466 }
13467 Py_INCREF(Py_None); resultobj = Py_None;
13468 return resultobj;
13469 fail:
13470 return NULL;
13471 }
13472
13473
13474 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13475 PyObject *resultobj = NULL;
13476 wxImage *arg1 = (wxImage *) 0 ;
13477 byte *arg2 = (byte *) 0 ;
13478 byte *arg3 = (byte *) 0 ;
13479 byte *arg4 = (byte *) 0 ;
13480 byte temp2 ;
13481 int res2 = 0 ;
13482 byte temp3 ;
13483 int res3 = 0 ;
13484 byte temp4 ;
13485 int res4 = 0 ;
13486 PyObject * obj0 = 0 ;
13487 char *kwnames[] = {
13488 (char *) "self", NULL
13489 };
13490
13491 arg2 = &temp2; res2 = SWIG_NEWOBJ;
13492 arg3 = &temp3; res3 = SWIG_NEWOBJ;
13493 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
13495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13496 if (SWIG_arg_fail(1)) SWIG_fail;
13497 {
13498 PyThreadState* __tstate = wxPyBeginAllowThreads();
13499 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
13500
13501 wxPyEndAllowThreads(__tstate);
13502 if (PyErr_Occurred()) SWIG_fail;
13503 }
13504 Py_INCREF(Py_None); resultobj = Py_None;
13505 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
13506 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
13507 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
13508 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
13509 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13510 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
13511 return resultobj;
13512 fail:
13513 return NULL;
13514 }
13515
13516
13517 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
13518 PyObject *resultobj = NULL;
13519 wxImage *arg1 = (wxImage *) 0 ;
13520 byte result;
13521 PyObject * obj0 = 0 ;
13522 char *kwnames[] = {
13523 (char *) "self", NULL
13524 };
13525
13526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
13527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13528 if (SWIG_arg_fail(1)) SWIG_fail;
13529 {
13530 PyThreadState* __tstate = wxPyBeginAllowThreads();
13531 result = (byte)(arg1)->GetMaskRed();
13532
13533 wxPyEndAllowThreads(__tstate);
13534 if (PyErr_Occurred()) SWIG_fail;
13535 }
13536 {
13537 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13538 }
13539 return resultobj;
13540 fail:
13541 return NULL;
13542 }
13543
13544
13545 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
13546 PyObject *resultobj = NULL;
13547 wxImage *arg1 = (wxImage *) 0 ;
13548 byte result;
13549 PyObject * obj0 = 0 ;
13550 char *kwnames[] = {
13551 (char *) "self", NULL
13552 };
13553
13554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
13555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13556 if (SWIG_arg_fail(1)) SWIG_fail;
13557 {
13558 PyThreadState* __tstate = wxPyBeginAllowThreads();
13559 result = (byte)(arg1)->GetMaskGreen();
13560
13561 wxPyEndAllowThreads(__tstate);
13562 if (PyErr_Occurred()) SWIG_fail;
13563 }
13564 {
13565 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13566 }
13567 return resultobj;
13568 fail:
13569 return NULL;
13570 }
13571
13572
13573 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
13574 PyObject *resultobj = NULL;
13575 wxImage *arg1 = (wxImage *) 0 ;
13576 byte result;
13577 PyObject * obj0 = 0 ;
13578 char *kwnames[] = {
13579 (char *) "self", NULL
13580 };
13581
13582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
13583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13584 if (SWIG_arg_fail(1)) SWIG_fail;
13585 {
13586 PyThreadState* __tstate = wxPyBeginAllowThreads();
13587 result = (byte)(arg1)->GetMaskBlue();
13588
13589 wxPyEndAllowThreads(__tstate);
13590 if (PyErr_Occurred()) SWIG_fail;
13591 }
13592 {
13593 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13594 }
13595 return resultobj;
13596 fail:
13597 return NULL;
13598 }
13599
13600
13601 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
13602 PyObject *resultobj = NULL;
13603 wxImage *arg1 = (wxImage *) 0 ;
13604 bool arg2 = (bool) true ;
13605 PyObject * obj0 = 0 ;
13606 PyObject * obj1 = 0 ;
13607 char *kwnames[] = {
13608 (char *) "self",(char *) "mask", NULL
13609 };
13610
13611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13613 if (SWIG_arg_fail(1)) SWIG_fail;
13614 if (obj1) {
13615 {
13616 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13617 if (SWIG_arg_fail(2)) SWIG_fail;
13618 }
13619 }
13620 {
13621 PyThreadState* __tstate = wxPyBeginAllowThreads();
13622 (arg1)->SetMask(arg2);
13623
13624 wxPyEndAllowThreads(__tstate);
13625 if (PyErr_Occurred()) SWIG_fail;
13626 }
13627 Py_INCREF(Py_None); resultobj = Py_None;
13628 return resultobj;
13629 fail:
13630 return NULL;
13631 }
13632
13633
13634 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13635 PyObject *resultobj = NULL;
13636 wxImage *arg1 = (wxImage *) 0 ;
13637 bool result;
13638 PyObject * obj0 = 0 ;
13639 char *kwnames[] = {
13640 (char *) "self", NULL
13641 };
13642
13643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13645 if (SWIG_arg_fail(1)) SWIG_fail;
13646 {
13647 PyThreadState* __tstate = wxPyBeginAllowThreads();
13648 result = (bool)(arg1)->HasMask();
13649
13650 wxPyEndAllowThreads(__tstate);
13651 if (PyErr_Occurred()) SWIG_fail;
13652 }
13653 {
13654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13655 }
13656 return resultobj;
13657 fail:
13658 return NULL;
13659 }
13660
13661
13662 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13663 PyObject *resultobj = NULL;
13664 wxImage *arg1 = (wxImage *) 0 ;
13665 double arg2 ;
13666 wxPoint *arg3 = 0 ;
13667 bool arg4 = (bool) true ;
13668 wxPoint *arg5 = (wxPoint *) NULL ;
13669 SwigValueWrapper<wxImage > result;
13670 wxPoint temp3 ;
13671 PyObject * obj0 = 0 ;
13672 PyObject * obj1 = 0 ;
13673 PyObject * obj2 = 0 ;
13674 PyObject * obj3 = 0 ;
13675 PyObject * obj4 = 0 ;
13676 char *kwnames[] = {
13677 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13678 };
13679
13680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13682 if (SWIG_arg_fail(1)) SWIG_fail;
13683 {
13684 arg2 = static_cast<double >(SWIG_As_double(obj1));
13685 if (SWIG_arg_fail(2)) SWIG_fail;
13686 }
13687 {
13688 arg3 = &temp3;
13689 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13690 }
13691 if (obj3) {
13692 {
13693 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
13694 if (SWIG_arg_fail(4)) SWIG_fail;
13695 }
13696 }
13697 if (obj4) {
13698 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13699 if (SWIG_arg_fail(5)) SWIG_fail;
13700 }
13701 {
13702 PyThreadState* __tstate = wxPyBeginAllowThreads();
13703 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13704
13705 wxPyEndAllowThreads(__tstate);
13706 if (PyErr_Occurred()) SWIG_fail;
13707 }
13708 {
13709 wxImage * resultptr;
13710 resultptr = new wxImage(static_cast<wxImage & >(result));
13711 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13712 }
13713 return resultobj;
13714 fail:
13715 return NULL;
13716 }
13717
13718
13719 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13720 PyObject *resultobj = NULL;
13721 wxImage *arg1 = (wxImage *) 0 ;
13722 bool arg2 = (bool) true ;
13723 SwigValueWrapper<wxImage > result;
13724 PyObject * obj0 = 0 ;
13725 PyObject * obj1 = 0 ;
13726 char *kwnames[] = {
13727 (char *) "self",(char *) "clockwise", NULL
13728 };
13729
13730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13732 if (SWIG_arg_fail(1)) SWIG_fail;
13733 if (obj1) {
13734 {
13735 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13736 if (SWIG_arg_fail(2)) SWIG_fail;
13737 }
13738 }
13739 {
13740 PyThreadState* __tstate = wxPyBeginAllowThreads();
13741 result = (arg1)->Rotate90(arg2);
13742
13743 wxPyEndAllowThreads(__tstate);
13744 if (PyErr_Occurred()) SWIG_fail;
13745 }
13746 {
13747 wxImage * resultptr;
13748 resultptr = new wxImage(static_cast<wxImage & >(result));
13749 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13750 }
13751 return resultobj;
13752 fail:
13753 return NULL;
13754 }
13755
13756
13757 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13758 PyObject *resultobj = NULL;
13759 wxImage *arg1 = (wxImage *) 0 ;
13760 bool arg2 = (bool) true ;
13761 SwigValueWrapper<wxImage > result;
13762 PyObject * obj0 = 0 ;
13763 PyObject * obj1 = 0 ;
13764 char *kwnames[] = {
13765 (char *) "self",(char *) "horizontally", NULL
13766 };
13767
13768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13770 if (SWIG_arg_fail(1)) SWIG_fail;
13771 if (obj1) {
13772 {
13773 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13774 if (SWIG_arg_fail(2)) SWIG_fail;
13775 }
13776 }
13777 {
13778 PyThreadState* __tstate = wxPyBeginAllowThreads();
13779 result = (arg1)->Mirror(arg2);
13780
13781 wxPyEndAllowThreads(__tstate);
13782 if (PyErr_Occurred()) SWIG_fail;
13783 }
13784 {
13785 wxImage * resultptr;
13786 resultptr = new wxImage(static_cast<wxImage & >(result));
13787 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13788 }
13789 return resultobj;
13790 fail:
13791 return NULL;
13792 }
13793
13794
13795 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13796 PyObject *resultobj = NULL;
13797 wxImage *arg1 = (wxImage *) 0 ;
13798 byte arg2 ;
13799 byte arg3 ;
13800 byte arg4 ;
13801 byte arg5 ;
13802 byte arg6 ;
13803 byte arg7 ;
13804 PyObject * obj0 = 0 ;
13805 PyObject * obj1 = 0 ;
13806 PyObject * obj2 = 0 ;
13807 PyObject * obj3 = 0 ;
13808 PyObject * obj4 = 0 ;
13809 PyObject * obj5 = 0 ;
13810 PyObject * obj6 = 0 ;
13811 char *kwnames[] = {
13812 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13813 };
13814
13815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13817 if (SWIG_arg_fail(1)) SWIG_fail;
13818 {
13819 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13820 if (SWIG_arg_fail(2)) SWIG_fail;
13821 }
13822 {
13823 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13824 if (SWIG_arg_fail(3)) SWIG_fail;
13825 }
13826 {
13827 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13828 if (SWIG_arg_fail(4)) SWIG_fail;
13829 }
13830 {
13831 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
13832 if (SWIG_arg_fail(5)) SWIG_fail;
13833 }
13834 {
13835 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj5));
13836 if (SWIG_arg_fail(6)) SWIG_fail;
13837 }
13838 {
13839 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj6));
13840 if (SWIG_arg_fail(7)) SWIG_fail;
13841 }
13842 {
13843 PyThreadState* __tstate = wxPyBeginAllowThreads();
13844 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13845
13846 wxPyEndAllowThreads(__tstate);
13847 if (PyErr_Occurred()) SWIG_fail;
13848 }
13849 Py_INCREF(Py_None); resultobj = Py_None;
13850 return resultobj;
13851 fail:
13852 return NULL;
13853 }
13854
13855
13856 static PyObject *_wrap_Image_ConvertToGreyscale(PyObject *, PyObject *args, PyObject *kwargs) {
13857 PyObject *resultobj = NULL;
13858 wxImage *arg1 = (wxImage *) 0 ;
13859 double arg2 = (double) 0.299 ;
13860 double arg3 = (double) 0.587 ;
13861 double arg4 = (double) 0.114 ;
13862 SwigValueWrapper<wxImage > result;
13863 PyObject * obj0 = 0 ;
13864 PyObject * obj1 = 0 ;
13865 PyObject * obj2 = 0 ;
13866 PyObject * obj3 = 0 ;
13867 char *kwnames[] = {
13868 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
13869 };
13870
13871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13873 if (SWIG_arg_fail(1)) SWIG_fail;
13874 if (obj1) {
13875 {
13876 arg2 = static_cast<double >(SWIG_As_double(obj1));
13877 if (SWIG_arg_fail(2)) SWIG_fail;
13878 }
13879 }
13880 if (obj2) {
13881 {
13882 arg3 = static_cast<double >(SWIG_As_double(obj2));
13883 if (SWIG_arg_fail(3)) SWIG_fail;
13884 }
13885 }
13886 if (obj3) {
13887 {
13888 arg4 = static_cast<double >(SWIG_As_double(obj3));
13889 if (SWIG_arg_fail(4)) SWIG_fail;
13890 }
13891 }
13892 {
13893 PyThreadState* __tstate = wxPyBeginAllowThreads();
13894 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
13895
13896 wxPyEndAllowThreads(__tstate);
13897 if (PyErr_Occurred()) SWIG_fail;
13898 }
13899 {
13900 wxImage * resultptr;
13901 resultptr = new wxImage(static_cast<wxImage & >(result));
13902 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13903 }
13904 return resultobj;
13905 fail:
13906 return NULL;
13907 }
13908
13909
13910 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13911 PyObject *resultobj = NULL;
13912 wxImage *arg1 = (wxImage *) 0 ;
13913 byte arg2 ;
13914 byte arg3 ;
13915 byte arg4 ;
13916 SwigValueWrapper<wxImage > result;
13917 PyObject * obj0 = 0 ;
13918 PyObject * obj1 = 0 ;
13919 PyObject * obj2 = 0 ;
13920 PyObject * obj3 = 0 ;
13921 char *kwnames[] = {
13922 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13923 };
13924
13925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13927 if (SWIG_arg_fail(1)) SWIG_fail;
13928 {
13929 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13930 if (SWIG_arg_fail(2)) SWIG_fail;
13931 }
13932 {
13933 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13934 if (SWIG_arg_fail(3)) SWIG_fail;
13935 }
13936 {
13937 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13938 if (SWIG_arg_fail(4)) SWIG_fail;
13939 }
13940 {
13941 PyThreadState* __tstate = wxPyBeginAllowThreads();
13942 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13943
13944 wxPyEndAllowThreads(__tstate);
13945 if (PyErr_Occurred()) SWIG_fail;
13946 }
13947 {
13948 wxImage * resultptr;
13949 resultptr = new wxImage(static_cast<wxImage & >(result));
13950 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13951 }
13952 return resultobj;
13953 fail:
13954 return NULL;
13955 }
13956
13957
13958 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13959 PyObject *resultobj = NULL;
13960 wxImage *arg1 = (wxImage *) 0 ;
13961 wxString *arg2 = 0 ;
13962 wxString *arg3 = 0 ;
13963 bool temp2 = false ;
13964 bool temp3 = false ;
13965 PyObject * obj0 = 0 ;
13966 PyObject * obj1 = 0 ;
13967 PyObject * obj2 = 0 ;
13968 char *kwnames[] = {
13969 (char *) "self",(char *) "name",(char *) "value", NULL
13970 };
13971
13972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13974 if (SWIG_arg_fail(1)) SWIG_fail;
13975 {
13976 arg2 = wxString_in_helper(obj1);
13977 if (arg2 == NULL) SWIG_fail;
13978 temp2 = true;
13979 }
13980 {
13981 arg3 = wxString_in_helper(obj2);
13982 if (arg3 == NULL) SWIG_fail;
13983 temp3 = true;
13984 }
13985 {
13986 PyThreadState* __tstate = wxPyBeginAllowThreads();
13987 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13988
13989 wxPyEndAllowThreads(__tstate);
13990 if (PyErr_Occurred()) SWIG_fail;
13991 }
13992 Py_INCREF(Py_None); resultobj = Py_None;
13993 {
13994 if (temp2)
13995 delete arg2;
13996 }
13997 {
13998 if (temp3)
13999 delete arg3;
14000 }
14001 return resultobj;
14002 fail:
14003 {
14004 if (temp2)
14005 delete arg2;
14006 }
14007 {
14008 if (temp3)
14009 delete arg3;
14010 }
14011 return NULL;
14012 }
14013
14014
14015 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
14016 PyObject *resultobj = NULL;
14017 wxImage *arg1 = (wxImage *) 0 ;
14018 wxString *arg2 = 0 ;
14019 int arg3 ;
14020 bool temp2 = false ;
14021 PyObject * obj0 = 0 ;
14022 PyObject * obj1 = 0 ;
14023 PyObject * obj2 = 0 ;
14024 char *kwnames[] = {
14025 (char *) "self",(char *) "name",(char *) "value", NULL
14026 };
14027
14028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
14029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14030 if (SWIG_arg_fail(1)) SWIG_fail;
14031 {
14032 arg2 = wxString_in_helper(obj1);
14033 if (arg2 == NULL) SWIG_fail;
14034 temp2 = true;
14035 }
14036 {
14037 arg3 = static_cast<int >(SWIG_As_int(obj2));
14038 if (SWIG_arg_fail(3)) SWIG_fail;
14039 }
14040 {
14041 PyThreadState* __tstate = wxPyBeginAllowThreads();
14042 (arg1)->SetOption((wxString const &)*arg2,arg3);
14043
14044 wxPyEndAllowThreads(__tstate);
14045 if (PyErr_Occurred()) SWIG_fail;
14046 }
14047 Py_INCREF(Py_None); resultobj = Py_None;
14048 {
14049 if (temp2)
14050 delete arg2;
14051 }
14052 return resultobj;
14053 fail:
14054 {
14055 if (temp2)
14056 delete arg2;
14057 }
14058 return NULL;
14059 }
14060
14061
14062 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
14063 PyObject *resultobj = NULL;
14064 wxImage *arg1 = (wxImage *) 0 ;
14065 wxString *arg2 = 0 ;
14066 wxString result;
14067 bool temp2 = false ;
14068 PyObject * obj0 = 0 ;
14069 PyObject * obj1 = 0 ;
14070 char *kwnames[] = {
14071 (char *) "self",(char *) "name", NULL
14072 };
14073
14074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
14075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14076 if (SWIG_arg_fail(1)) SWIG_fail;
14077 {
14078 arg2 = wxString_in_helper(obj1);
14079 if (arg2 == NULL) SWIG_fail;
14080 temp2 = true;
14081 }
14082 {
14083 PyThreadState* __tstate = wxPyBeginAllowThreads();
14084 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
14085
14086 wxPyEndAllowThreads(__tstate);
14087 if (PyErr_Occurred()) SWIG_fail;
14088 }
14089 {
14090 #if wxUSE_UNICODE
14091 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14092 #else
14093 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14094 #endif
14095 }
14096 {
14097 if (temp2)
14098 delete arg2;
14099 }
14100 return resultobj;
14101 fail:
14102 {
14103 if (temp2)
14104 delete arg2;
14105 }
14106 return NULL;
14107 }
14108
14109
14110 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
14111 PyObject *resultobj = NULL;
14112 wxImage *arg1 = (wxImage *) 0 ;
14113 wxString *arg2 = 0 ;
14114 int result;
14115 bool temp2 = false ;
14116 PyObject * obj0 = 0 ;
14117 PyObject * obj1 = 0 ;
14118 char *kwnames[] = {
14119 (char *) "self",(char *) "name", NULL
14120 };
14121
14122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
14123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14124 if (SWIG_arg_fail(1)) SWIG_fail;
14125 {
14126 arg2 = wxString_in_helper(obj1);
14127 if (arg2 == NULL) SWIG_fail;
14128 temp2 = true;
14129 }
14130 {
14131 PyThreadState* __tstate = wxPyBeginAllowThreads();
14132 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
14133
14134 wxPyEndAllowThreads(__tstate);
14135 if (PyErr_Occurred()) SWIG_fail;
14136 }
14137 {
14138 resultobj = SWIG_From_int(static_cast<int >(result));
14139 }
14140 {
14141 if (temp2)
14142 delete arg2;
14143 }
14144 return resultobj;
14145 fail:
14146 {
14147 if (temp2)
14148 delete arg2;
14149 }
14150 return NULL;
14151 }
14152
14153
14154 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
14155 PyObject *resultobj = NULL;
14156 wxImage *arg1 = (wxImage *) 0 ;
14157 wxString *arg2 = 0 ;
14158 bool result;
14159 bool temp2 = false ;
14160 PyObject * obj0 = 0 ;
14161 PyObject * obj1 = 0 ;
14162 char *kwnames[] = {
14163 (char *) "self",(char *) "name", NULL
14164 };
14165
14166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
14167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14168 if (SWIG_arg_fail(1)) SWIG_fail;
14169 {
14170 arg2 = wxString_in_helper(obj1);
14171 if (arg2 == NULL) SWIG_fail;
14172 temp2 = true;
14173 }
14174 {
14175 PyThreadState* __tstate = wxPyBeginAllowThreads();
14176 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
14177
14178 wxPyEndAllowThreads(__tstate);
14179 if (PyErr_Occurred()) SWIG_fail;
14180 }
14181 {
14182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14183 }
14184 {
14185 if (temp2)
14186 delete arg2;
14187 }
14188 return resultobj;
14189 fail:
14190 {
14191 if (temp2)
14192 delete arg2;
14193 }
14194 return NULL;
14195 }
14196
14197
14198 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
14199 PyObject *resultobj = NULL;
14200 wxImage *arg1 = (wxImage *) 0 ;
14201 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
14202 unsigned long result;
14203 PyObject * obj0 = 0 ;
14204 PyObject * obj1 = 0 ;
14205 char *kwnames[] = {
14206 (char *) "self",(char *) "stopafter", NULL
14207 };
14208
14209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
14210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14211 if (SWIG_arg_fail(1)) SWIG_fail;
14212 if (obj1) {
14213 {
14214 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
14215 if (SWIG_arg_fail(2)) SWIG_fail;
14216 }
14217 }
14218 {
14219 PyThreadState* __tstate = wxPyBeginAllowThreads();
14220 result = (unsigned long)(arg1)->CountColours(arg2);
14221
14222 wxPyEndAllowThreads(__tstate);
14223 if (PyErr_Occurred()) SWIG_fail;
14224 }
14225 {
14226 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
14227 }
14228 return resultobj;
14229 fail:
14230 return NULL;
14231 }
14232
14233
14234 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
14235 PyObject *resultobj = NULL;
14236 wxImage *arg1 = (wxImage *) 0 ;
14237 wxImageHistogram *arg2 = 0 ;
14238 unsigned long result;
14239 PyObject * obj0 = 0 ;
14240 PyObject * obj1 = 0 ;
14241 char *kwnames[] = {
14242 (char *) "self",(char *) "h", NULL
14243 };
14244
14245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
14246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14247 if (SWIG_arg_fail(1)) SWIG_fail;
14248 {
14249 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
14250 if (SWIG_arg_fail(2)) SWIG_fail;
14251 if (arg2 == NULL) {
14252 SWIG_null_ref("wxImageHistogram");
14253 }
14254 if (SWIG_arg_fail(2)) SWIG_fail;
14255 }
14256 {
14257 PyThreadState* __tstate = wxPyBeginAllowThreads();
14258 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
14259
14260 wxPyEndAllowThreads(__tstate);
14261 if (PyErr_Occurred()) SWIG_fail;
14262 }
14263 {
14264 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
14265 }
14266 return resultobj;
14267 fail:
14268 return NULL;
14269 }
14270
14271
14272 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14273 PyObject *resultobj = NULL;
14274 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14275 PyObject * obj0 = 0 ;
14276 char *kwnames[] = {
14277 (char *) "handler", NULL
14278 };
14279
14280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
14281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14282 if (SWIG_arg_fail(1)) SWIG_fail;
14283 {
14284 PyThreadState* __tstate = wxPyBeginAllowThreads();
14285 wxImage::AddHandler(arg1);
14286
14287 wxPyEndAllowThreads(__tstate);
14288 if (PyErr_Occurred()) SWIG_fail;
14289 }
14290 Py_INCREF(Py_None); resultobj = Py_None;
14291 return resultobj;
14292 fail:
14293 return NULL;
14294 }
14295
14296
14297 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14298 PyObject *resultobj = NULL;
14299 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14300 PyObject * obj0 = 0 ;
14301 char *kwnames[] = {
14302 (char *) "handler", NULL
14303 };
14304
14305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
14306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14307 if (SWIG_arg_fail(1)) SWIG_fail;
14308 {
14309 PyThreadState* __tstate = wxPyBeginAllowThreads();
14310 wxImage::InsertHandler(arg1);
14311
14312 wxPyEndAllowThreads(__tstate);
14313 if (PyErr_Occurred()) SWIG_fail;
14314 }
14315 Py_INCREF(Py_None); resultobj = Py_None;
14316 return resultobj;
14317 fail:
14318 return NULL;
14319 }
14320
14321
14322 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14323 PyObject *resultobj = NULL;
14324 wxString *arg1 = 0 ;
14325 bool result;
14326 bool temp1 = false ;
14327 PyObject * obj0 = 0 ;
14328 char *kwnames[] = {
14329 (char *) "name", NULL
14330 };
14331
14332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
14333 {
14334 arg1 = wxString_in_helper(obj0);
14335 if (arg1 == NULL) SWIG_fail;
14336 temp1 = true;
14337 }
14338 {
14339 PyThreadState* __tstate = wxPyBeginAllowThreads();
14340 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
14341
14342 wxPyEndAllowThreads(__tstate);
14343 if (PyErr_Occurred()) SWIG_fail;
14344 }
14345 {
14346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14347 }
14348 {
14349 if (temp1)
14350 delete arg1;
14351 }
14352 return resultobj;
14353 fail:
14354 {
14355 if (temp1)
14356 delete arg1;
14357 }
14358 return NULL;
14359 }
14360
14361
14362 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14363 PyObject *resultobj = NULL;
14364 wxString result;
14365 char *kwnames[] = {
14366 NULL
14367 };
14368
14369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
14370 {
14371 PyThreadState* __tstate = wxPyBeginAllowThreads();
14372 result = wxImage::GetImageExtWildcard();
14373
14374 wxPyEndAllowThreads(__tstate);
14375 if (PyErr_Occurred()) SWIG_fail;
14376 }
14377 {
14378 #if wxUSE_UNICODE
14379 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14380 #else
14381 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14382 #endif
14383 }
14384 return resultobj;
14385 fail:
14386 return NULL;
14387 }
14388
14389
14390 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14391 PyObject *resultobj = NULL;
14392 wxImage *arg1 = (wxImage *) 0 ;
14393 int arg2 = (int) -1 ;
14394 wxBitmap result;
14395 PyObject * obj0 = 0 ;
14396 PyObject * obj1 = 0 ;
14397 char *kwnames[] = {
14398 (char *) "self",(char *) "depth", NULL
14399 };
14400
14401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
14402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14403 if (SWIG_arg_fail(1)) SWIG_fail;
14404 if (obj1) {
14405 {
14406 arg2 = static_cast<int >(SWIG_As_int(obj1));
14407 if (SWIG_arg_fail(2)) SWIG_fail;
14408 }
14409 }
14410 {
14411 if (!wxPyCheckForApp()) SWIG_fail;
14412 PyThreadState* __tstate = wxPyBeginAllowThreads();
14413 result = wxImage_ConvertToBitmap(arg1,arg2);
14414
14415 wxPyEndAllowThreads(__tstate);
14416 if (PyErr_Occurred()) SWIG_fail;
14417 }
14418 {
14419 wxBitmap * resultptr;
14420 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
14421 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14422 }
14423 return resultobj;
14424 fail:
14425 return NULL;
14426 }
14427
14428
14429 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14430 PyObject *resultobj = NULL;
14431 wxImage *arg1 = (wxImage *) 0 ;
14432 byte arg2 ;
14433 byte arg3 ;
14434 byte arg4 ;
14435 wxBitmap result;
14436 PyObject * obj0 = 0 ;
14437 PyObject * obj1 = 0 ;
14438 PyObject * obj2 = 0 ;
14439 PyObject * obj3 = 0 ;
14440 char *kwnames[] = {
14441 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
14442 };
14443
14444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14446 if (SWIG_arg_fail(1)) SWIG_fail;
14447 {
14448 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
14449 if (SWIG_arg_fail(2)) SWIG_fail;
14450 }
14451 {
14452 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
14453 if (SWIG_arg_fail(3)) SWIG_fail;
14454 }
14455 {
14456 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
14457 if (SWIG_arg_fail(4)) SWIG_fail;
14458 }
14459 {
14460 if (!wxPyCheckForApp()) SWIG_fail;
14461 PyThreadState* __tstate = wxPyBeginAllowThreads();
14462 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
14463
14464 wxPyEndAllowThreads(__tstate);
14465 if (PyErr_Occurred()) SWIG_fail;
14466 }
14467 {
14468 wxBitmap * resultptr;
14469 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
14470 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14471 }
14472 return resultobj;
14473 fail:
14474 return NULL;
14475 }
14476
14477
14478 static PyObject *_wrap_Image_RotateHue(PyObject *, PyObject *args, PyObject *kwargs) {
14479 PyObject *resultobj = NULL;
14480 wxImage *arg1 = (wxImage *) 0 ;
14481 double arg2 ;
14482 PyObject * obj0 = 0 ;
14483 PyObject * obj1 = 0 ;
14484 char *kwnames[] = {
14485 (char *) "self",(char *) "angle", NULL
14486 };
14487
14488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) goto fail;
14489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14490 if (SWIG_arg_fail(1)) SWIG_fail;
14491 {
14492 arg2 = static_cast<double >(SWIG_As_double(obj1));
14493 if (SWIG_arg_fail(2)) SWIG_fail;
14494 }
14495 {
14496 PyThreadState* __tstate = wxPyBeginAllowThreads();
14497 (arg1)->RotateHue(arg2);
14498
14499 wxPyEndAllowThreads(__tstate);
14500 if (PyErr_Occurred()) SWIG_fail;
14501 }
14502 Py_INCREF(Py_None); resultobj = Py_None;
14503 return resultobj;
14504 fail:
14505 return NULL;
14506 }
14507
14508
14509 static PyObject *_wrap_Image_RGBtoHSV(PyObject *, PyObject *args, PyObject *kwargs) {
14510 PyObject *resultobj = NULL;
14511 wxImage_RGBValue arg1 ;
14512 wxImage_HSVValue result;
14513 PyObject * obj0 = 0 ;
14514 char *kwnames[] = {
14515 (char *) "rgb", NULL
14516 };
14517
14518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) goto fail;
14519 {
14520 wxImage_RGBValue * argp;
14521 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION);
14522 if (SWIG_arg_fail(1)) SWIG_fail;
14523 if (argp == NULL) {
14524 SWIG_null_ref("wxImage_RGBValue");
14525 }
14526 if (SWIG_arg_fail(1)) SWIG_fail;
14527 arg1 = *argp;
14528 }
14529 {
14530 PyThreadState* __tstate = wxPyBeginAllowThreads();
14531 result = wxImage::RGBtoHSV(arg1);
14532
14533 wxPyEndAllowThreads(__tstate);
14534 if (PyErr_Occurred()) SWIG_fail;
14535 }
14536 {
14537 wxImage_HSVValue * resultptr;
14538 resultptr = new wxImage_HSVValue(static_cast<wxImage_HSVValue & >(result));
14539 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_HSVValue, 1);
14540 }
14541 return resultobj;
14542 fail:
14543 return NULL;
14544 }
14545
14546
14547 static PyObject *_wrap_Image_HSVtoRGB(PyObject *, PyObject *args, PyObject *kwargs) {
14548 PyObject *resultobj = NULL;
14549 wxImage_HSVValue arg1 ;
14550 wxImage_RGBValue result;
14551 PyObject * obj0 = 0 ;
14552 char *kwnames[] = {
14553 (char *) "hsv", NULL
14554 };
14555
14556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) goto fail;
14557 {
14558 wxImage_HSVValue * argp;
14559 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION);
14560 if (SWIG_arg_fail(1)) SWIG_fail;
14561 if (argp == NULL) {
14562 SWIG_null_ref("wxImage_HSVValue");
14563 }
14564 if (SWIG_arg_fail(1)) SWIG_fail;
14565 arg1 = *argp;
14566 }
14567 {
14568 PyThreadState* __tstate = wxPyBeginAllowThreads();
14569 result = wxImage::HSVtoRGB(arg1);
14570
14571 wxPyEndAllowThreads(__tstate);
14572 if (PyErr_Occurred()) SWIG_fail;
14573 }
14574 {
14575 wxImage_RGBValue * resultptr;
14576 resultptr = new wxImage_RGBValue(static_cast<wxImage_RGBValue & >(result));
14577 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_RGBValue, 1);
14578 }
14579 return resultobj;
14580 fail:
14581 return NULL;
14582 }
14583
14584
14585 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
14586 PyObject *obj;
14587 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14588 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
14589 Py_INCREF(obj);
14590 return Py_BuildValue((char *)"");
14591 }
14592 static int _wrap_NullImage_set(PyObject *) {
14593 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
14594 return 1;
14595 }
14596
14597
14598 static PyObject *_wrap_NullImage_get(void) {
14599 PyObject *pyobj = NULL;
14600
14601 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
14602 return pyobj;
14603 }
14604
14605
14606 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
14607 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
14608 return 1;
14609 }
14610
14611
14612 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
14613 PyObject *pyobj = NULL;
14614
14615 {
14616 #if wxUSE_UNICODE
14617 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14618 #else
14619 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14620 #endif
14621 }
14622 return pyobj;
14623 }
14624
14625
14626 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
14627 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
14628 return 1;
14629 }
14630
14631
14632 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
14633 PyObject *pyobj = NULL;
14634
14635 {
14636 #if wxUSE_UNICODE
14637 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14638 #else
14639 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14640 #endif
14641 }
14642 return pyobj;
14643 }
14644
14645
14646 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
14647 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
14648 return 1;
14649 }
14650
14651
14652 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
14653 PyObject *pyobj = NULL;
14654
14655 {
14656 #if wxUSE_UNICODE
14657 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14658 #else
14659 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14660 #endif
14661 }
14662 return pyobj;
14663 }
14664
14665
14666 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
14667 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
14668 return 1;
14669 }
14670
14671
14672 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
14673 PyObject *pyobj = NULL;
14674
14675 {
14676 #if wxUSE_UNICODE
14677 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14678 #else
14679 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14680 #endif
14681 }
14682 return pyobj;
14683 }
14684
14685
14686 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
14687 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
14688 return 1;
14689 }
14690
14691
14692 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
14693 PyObject *pyobj = NULL;
14694
14695 {
14696 #if wxUSE_UNICODE
14697 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14698 #else
14699 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14700 #endif
14701 }
14702 return pyobj;
14703 }
14704
14705
14706 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
14707 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
14708 return 1;
14709 }
14710
14711
14712 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
14713 PyObject *pyobj = NULL;
14714
14715 {
14716 #if wxUSE_UNICODE
14717 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14718 #else
14719 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14720 #endif
14721 }
14722 return pyobj;
14723 }
14724
14725
14726 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
14727 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
14728 return 1;
14729 }
14730
14731
14732 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
14733 PyObject *pyobj = NULL;
14734
14735 {
14736 #if wxUSE_UNICODE
14737 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14738 #else
14739 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14740 #endif
14741 }
14742 return pyobj;
14743 }
14744
14745
14746 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
14747 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
14748 return 1;
14749 }
14750
14751
14752 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
14753 PyObject *pyobj = NULL;
14754
14755 {
14756 #if wxUSE_UNICODE
14757 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14758 #else
14759 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14760 #endif
14761 }
14762 return pyobj;
14763 }
14764
14765
14766 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14767 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14768 return 1;
14769 }
14770
14771
14772 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14773 PyObject *pyobj = NULL;
14774
14775 {
14776 #if wxUSE_UNICODE
14777 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14778 #else
14779 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14780 #endif
14781 }
14782 return pyobj;
14783 }
14784
14785
14786 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14787 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14788 return 1;
14789 }
14790
14791
14792 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14793 PyObject *pyobj = NULL;
14794
14795 {
14796 #if wxUSE_UNICODE
14797 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14798 #else
14799 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14800 #endif
14801 }
14802 return pyobj;
14803 }
14804
14805
14806 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14807 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14808 return 1;
14809 }
14810
14811
14812 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14813 PyObject *pyobj = NULL;
14814
14815 {
14816 #if wxUSE_UNICODE
14817 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14818 #else
14819 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14820 #endif
14821 }
14822 return pyobj;
14823 }
14824
14825
14826 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14827 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14828 return 1;
14829 }
14830
14831
14832 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14833 PyObject *pyobj = NULL;
14834
14835 {
14836 #if wxUSE_UNICODE
14837 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14838 #else
14839 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14840 #endif
14841 }
14842 return pyobj;
14843 }
14844
14845
14846 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14847 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14848 return 1;
14849 }
14850
14851
14852 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14853 PyObject *pyobj = NULL;
14854
14855 {
14856 #if wxUSE_UNICODE
14857 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14858 #else
14859 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14860 #endif
14861 }
14862 return pyobj;
14863 }
14864
14865
14866 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14867 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14868 return 1;
14869 }
14870
14871
14872 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14873 PyObject *pyobj = NULL;
14874
14875 {
14876 #if wxUSE_UNICODE
14877 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14878 #else
14879 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14880 #endif
14881 }
14882 return pyobj;
14883 }
14884
14885
14886 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14887 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14888 return 1;
14889 }
14890
14891
14892 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14893 PyObject *pyobj = NULL;
14894
14895 {
14896 #if wxUSE_UNICODE
14897 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14898 #else
14899 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14900 #endif
14901 }
14902 return pyobj;
14903 }
14904
14905
14906 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14907 PyObject *resultobj = NULL;
14908 wxBMPHandler *result;
14909 char *kwnames[] = {
14910 NULL
14911 };
14912
14913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14914 {
14915 PyThreadState* __tstate = wxPyBeginAllowThreads();
14916 result = (wxBMPHandler *)new wxBMPHandler();
14917
14918 wxPyEndAllowThreads(__tstate);
14919 if (PyErr_Occurred()) SWIG_fail;
14920 }
14921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14922 return resultobj;
14923 fail:
14924 return NULL;
14925 }
14926
14927
14928 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14929 PyObject *obj;
14930 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14931 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14932 Py_INCREF(obj);
14933 return Py_BuildValue((char *)"");
14934 }
14935 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14936 PyObject *resultobj = NULL;
14937 wxICOHandler *result;
14938 char *kwnames[] = {
14939 NULL
14940 };
14941
14942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14943 {
14944 PyThreadState* __tstate = wxPyBeginAllowThreads();
14945 result = (wxICOHandler *)new wxICOHandler();
14946
14947 wxPyEndAllowThreads(__tstate);
14948 if (PyErr_Occurred()) SWIG_fail;
14949 }
14950 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14951 return resultobj;
14952 fail:
14953 return NULL;
14954 }
14955
14956
14957 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14958 PyObject *obj;
14959 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14960 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14961 Py_INCREF(obj);
14962 return Py_BuildValue((char *)"");
14963 }
14964 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14965 PyObject *resultobj = NULL;
14966 wxCURHandler *result;
14967 char *kwnames[] = {
14968 NULL
14969 };
14970
14971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14972 {
14973 PyThreadState* __tstate = wxPyBeginAllowThreads();
14974 result = (wxCURHandler *)new wxCURHandler();
14975
14976 wxPyEndAllowThreads(__tstate);
14977 if (PyErr_Occurred()) SWIG_fail;
14978 }
14979 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14980 return resultobj;
14981 fail:
14982 return NULL;
14983 }
14984
14985
14986 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14987 PyObject *obj;
14988 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14989 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14990 Py_INCREF(obj);
14991 return Py_BuildValue((char *)"");
14992 }
14993 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14994 PyObject *resultobj = NULL;
14995 wxANIHandler *result;
14996 char *kwnames[] = {
14997 NULL
14998 };
14999
15000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
15001 {
15002 PyThreadState* __tstate = wxPyBeginAllowThreads();
15003 result = (wxANIHandler *)new wxANIHandler();
15004
15005 wxPyEndAllowThreads(__tstate);
15006 if (PyErr_Occurred()) SWIG_fail;
15007 }
15008 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
15009 return resultobj;
15010 fail:
15011 return NULL;
15012 }
15013
15014
15015 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
15016 PyObject *obj;
15017 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15018 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
15019 Py_INCREF(obj);
15020 return Py_BuildValue((char *)"");
15021 }
15022 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15023 PyObject *resultobj = NULL;
15024 wxPNGHandler *result;
15025 char *kwnames[] = {
15026 NULL
15027 };
15028
15029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
15030 {
15031 PyThreadState* __tstate = wxPyBeginAllowThreads();
15032 result = (wxPNGHandler *)new wxPNGHandler();
15033
15034 wxPyEndAllowThreads(__tstate);
15035 if (PyErr_Occurred()) SWIG_fail;
15036 }
15037 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
15038 return resultobj;
15039 fail:
15040 return NULL;
15041 }
15042
15043
15044 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
15045 PyObject *obj;
15046 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15047 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
15048 Py_INCREF(obj);
15049 return Py_BuildValue((char *)"");
15050 }
15051 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15052 PyObject *resultobj = NULL;
15053 wxGIFHandler *result;
15054 char *kwnames[] = {
15055 NULL
15056 };
15057
15058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
15059 {
15060 PyThreadState* __tstate = wxPyBeginAllowThreads();
15061 result = (wxGIFHandler *)new wxGIFHandler();
15062
15063 wxPyEndAllowThreads(__tstate);
15064 if (PyErr_Occurred()) SWIG_fail;
15065 }
15066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
15067 return resultobj;
15068 fail:
15069 return NULL;
15070 }
15071
15072
15073 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
15074 PyObject *obj;
15075 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15076 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
15077 Py_INCREF(obj);
15078 return Py_BuildValue((char *)"");
15079 }
15080 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15081 PyObject *resultobj = NULL;
15082 wxPCXHandler *result;
15083 char *kwnames[] = {
15084 NULL
15085 };
15086
15087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
15088 {
15089 PyThreadState* __tstate = wxPyBeginAllowThreads();
15090 result = (wxPCXHandler *)new wxPCXHandler();
15091
15092 wxPyEndAllowThreads(__tstate);
15093 if (PyErr_Occurred()) SWIG_fail;
15094 }
15095 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
15096 return resultobj;
15097 fail:
15098 return NULL;
15099 }
15100
15101
15102 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
15103 PyObject *obj;
15104 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15105 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
15106 Py_INCREF(obj);
15107 return Py_BuildValue((char *)"");
15108 }
15109 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15110 PyObject *resultobj = NULL;
15111 wxJPEGHandler *result;
15112 char *kwnames[] = {
15113 NULL
15114 };
15115
15116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
15117 {
15118 PyThreadState* __tstate = wxPyBeginAllowThreads();
15119 result = (wxJPEGHandler *)new wxJPEGHandler();
15120
15121 wxPyEndAllowThreads(__tstate);
15122 if (PyErr_Occurred()) SWIG_fail;
15123 }
15124 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
15125 return resultobj;
15126 fail:
15127 return NULL;
15128 }
15129
15130
15131 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
15132 PyObject *obj;
15133 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15134 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
15135 Py_INCREF(obj);
15136 return Py_BuildValue((char *)"");
15137 }
15138 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15139 PyObject *resultobj = NULL;
15140 wxPNMHandler *result;
15141 char *kwnames[] = {
15142 NULL
15143 };
15144
15145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
15146 {
15147 PyThreadState* __tstate = wxPyBeginAllowThreads();
15148 result = (wxPNMHandler *)new wxPNMHandler();
15149
15150 wxPyEndAllowThreads(__tstate);
15151 if (PyErr_Occurred()) SWIG_fail;
15152 }
15153 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
15154 return resultobj;
15155 fail:
15156 return NULL;
15157 }
15158
15159
15160 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
15161 PyObject *obj;
15162 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15163 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
15164 Py_INCREF(obj);
15165 return Py_BuildValue((char *)"");
15166 }
15167 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15168 PyObject *resultobj = NULL;
15169 wxXPMHandler *result;
15170 char *kwnames[] = {
15171 NULL
15172 };
15173
15174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
15175 {
15176 PyThreadState* __tstate = wxPyBeginAllowThreads();
15177 result = (wxXPMHandler *)new wxXPMHandler();
15178
15179 wxPyEndAllowThreads(__tstate);
15180 if (PyErr_Occurred()) SWIG_fail;
15181 }
15182 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
15183 return resultobj;
15184 fail:
15185 return NULL;
15186 }
15187
15188
15189 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
15190 PyObject *obj;
15191 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15192 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
15193 Py_INCREF(obj);
15194 return Py_BuildValue((char *)"");
15195 }
15196 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15197 PyObject *resultobj = NULL;
15198 wxTIFFHandler *result;
15199 char *kwnames[] = {
15200 NULL
15201 };
15202
15203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
15204 {
15205 PyThreadState* __tstate = wxPyBeginAllowThreads();
15206 result = (wxTIFFHandler *)new wxTIFFHandler();
15207
15208 wxPyEndAllowThreads(__tstate);
15209 if (PyErr_Occurred()) SWIG_fail;
15210 }
15211 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
15212 return resultobj;
15213 fail:
15214 return NULL;
15215 }
15216
15217
15218 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
15219 PyObject *obj;
15220 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15221 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
15222 Py_INCREF(obj);
15223 return Py_BuildValue((char *)"");
15224 }
15225 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
15226 PyObject *resultobj = NULL;
15227 wxImage *arg1 = 0 ;
15228 wxImage *arg2 = 0 ;
15229 int arg3 = (int) 236 ;
15230 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
15231 bool result;
15232 PyObject * obj0 = 0 ;
15233 PyObject * obj1 = 0 ;
15234 PyObject * obj2 = 0 ;
15235 PyObject * obj3 = 0 ;
15236 char *kwnames[] = {
15237 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
15238 };
15239
15240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15241 {
15242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15243 if (SWIG_arg_fail(1)) SWIG_fail;
15244 if (arg1 == NULL) {
15245 SWIG_null_ref("wxImage");
15246 }
15247 if (SWIG_arg_fail(1)) SWIG_fail;
15248 }
15249 {
15250 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15251 if (SWIG_arg_fail(2)) SWIG_fail;
15252 if (arg2 == NULL) {
15253 SWIG_null_ref("wxImage");
15254 }
15255 if (SWIG_arg_fail(2)) SWIG_fail;
15256 }
15257 if (obj2) {
15258 {
15259 arg3 = static_cast<int >(SWIG_As_int(obj2));
15260 if (SWIG_arg_fail(3)) SWIG_fail;
15261 }
15262 }
15263 if (obj3) {
15264 {
15265 arg4 = static_cast<int >(SWIG_As_int(obj3));
15266 if (SWIG_arg_fail(4)) SWIG_fail;
15267 }
15268 }
15269 {
15270 PyThreadState* __tstate = wxPyBeginAllowThreads();
15271 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
15272
15273 wxPyEndAllowThreads(__tstate);
15274 if (PyErr_Occurred()) SWIG_fail;
15275 }
15276 {
15277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15278 }
15279 return resultobj;
15280 fail:
15281 return NULL;
15282 }
15283
15284
15285 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
15286 PyObject *obj;
15287 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15288 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
15289 Py_INCREF(obj);
15290 return Py_BuildValue((char *)"");
15291 }
15292 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15293 PyObject *resultobj = NULL;
15294 wxEvtHandler *result;
15295 char *kwnames[] = {
15296 NULL
15297 };
15298
15299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
15300 {
15301 PyThreadState* __tstate = wxPyBeginAllowThreads();
15302 result = (wxEvtHandler *)new wxEvtHandler();
15303
15304 wxPyEndAllowThreads(__tstate);
15305 if (PyErr_Occurred()) SWIG_fail;
15306 }
15307 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
15308 return resultobj;
15309 fail:
15310 return NULL;
15311 }
15312
15313
15314 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15315 PyObject *resultobj = NULL;
15316 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15317 wxEvtHandler *result;
15318 PyObject * obj0 = 0 ;
15319 char *kwnames[] = {
15320 (char *) "self", NULL
15321 };
15322
15323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
15324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15325 if (SWIG_arg_fail(1)) SWIG_fail;
15326 {
15327 PyThreadState* __tstate = wxPyBeginAllowThreads();
15328 result = (wxEvtHandler *)(arg1)->GetNextHandler();
15329
15330 wxPyEndAllowThreads(__tstate);
15331 if (PyErr_Occurred()) SWIG_fail;
15332 }
15333 {
15334 resultobj = wxPyMake_wxObject(result, 0);
15335 }
15336 return resultobj;
15337 fail:
15338 return NULL;
15339 }
15340
15341
15342 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15343 PyObject *resultobj = NULL;
15344 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15345 wxEvtHandler *result;
15346 PyObject * obj0 = 0 ;
15347 char *kwnames[] = {
15348 (char *) "self", NULL
15349 };
15350
15351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
15352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15353 if (SWIG_arg_fail(1)) SWIG_fail;
15354 {
15355 PyThreadState* __tstate = wxPyBeginAllowThreads();
15356 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
15357
15358 wxPyEndAllowThreads(__tstate);
15359 if (PyErr_Occurred()) SWIG_fail;
15360 }
15361 {
15362 resultobj = wxPyMake_wxObject(result, 0);
15363 }
15364 return resultobj;
15365 fail:
15366 return NULL;
15367 }
15368
15369
15370 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15371 PyObject *resultobj = NULL;
15372 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15373 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15374 PyObject * obj0 = 0 ;
15375 PyObject * obj1 = 0 ;
15376 char *kwnames[] = {
15377 (char *) "self",(char *) "handler", NULL
15378 };
15379
15380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
15381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15382 if (SWIG_arg_fail(1)) SWIG_fail;
15383 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15384 if (SWIG_arg_fail(2)) SWIG_fail;
15385 {
15386 PyThreadState* __tstate = wxPyBeginAllowThreads();
15387 (arg1)->SetNextHandler(arg2);
15388
15389 wxPyEndAllowThreads(__tstate);
15390 if (PyErr_Occurred()) SWIG_fail;
15391 }
15392 Py_INCREF(Py_None); resultobj = Py_None;
15393 return resultobj;
15394 fail:
15395 return NULL;
15396 }
15397
15398
15399 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15400 PyObject *resultobj = NULL;
15401 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15402 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15403 PyObject * obj0 = 0 ;
15404 PyObject * obj1 = 0 ;
15405 char *kwnames[] = {
15406 (char *) "self",(char *) "handler", NULL
15407 };
15408
15409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
15410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15411 if (SWIG_arg_fail(1)) SWIG_fail;
15412 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15413 if (SWIG_arg_fail(2)) SWIG_fail;
15414 {
15415 PyThreadState* __tstate = wxPyBeginAllowThreads();
15416 (arg1)->SetPreviousHandler(arg2);
15417
15418 wxPyEndAllowThreads(__tstate);
15419 if (PyErr_Occurred()) SWIG_fail;
15420 }
15421 Py_INCREF(Py_None); resultobj = Py_None;
15422 return resultobj;
15423 fail:
15424 return NULL;
15425 }
15426
15427
15428 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15429 PyObject *resultobj = NULL;
15430 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15431 bool result;
15432 PyObject * obj0 = 0 ;
15433 char *kwnames[] = {
15434 (char *) "self", NULL
15435 };
15436
15437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
15438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15439 if (SWIG_arg_fail(1)) SWIG_fail;
15440 {
15441 PyThreadState* __tstate = wxPyBeginAllowThreads();
15442 result = (bool)(arg1)->GetEvtHandlerEnabled();
15443
15444 wxPyEndAllowThreads(__tstate);
15445 if (PyErr_Occurred()) SWIG_fail;
15446 }
15447 {
15448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15449 }
15450 return resultobj;
15451 fail:
15452 return NULL;
15453 }
15454
15455
15456 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15457 PyObject *resultobj = NULL;
15458 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15459 bool arg2 ;
15460 PyObject * obj0 = 0 ;
15461 PyObject * obj1 = 0 ;
15462 char *kwnames[] = {
15463 (char *) "self",(char *) "enabled", NULL
15464 };
15465
15466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
15467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15468 if (SWIG_arg_fail(1)) SWIG_fail;
15469 {
15470 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
15471 if (SWIG_arg_fail(2)) SWIG_fail;
15472 }
15473 {
15474 PyThreadState* __tstate = wxPyBeginAllowThreads();
15475 (arg1)->SetEvtHandlerEnabled(arg2);
15476
15477 wxPyEndAllowThreads(__tstate);
15478 if (PyErr_Occurred()) SWIG_fail;
15479 }
15480 Py_INCREF(Py_None); resultobj = Py_None;
15481 return resultobj;
15482 fail:
15483 return NULL;
15484 }
15485
15486
15487 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15488 PyObject *resultobj = NULL;
15489 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15490 wxEvent *arg2 = 0 ;
15491 bool result;
15492 PyObject * obj0 = 0 ;
15493 PyObject * obj1 = 0 ;
15494 char *kwnames[] = {
15495 (char *) "self",(char *) "event", NULL
15496 };
15497
15498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
15499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15500 if (SWIG_arg_fail(1)) SWIG_fail;
15501 {
15502 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15503 if (SWIG_arg_fail(2)) SWIG_fail;
15504 if (arg2 == NULL) {
15505 SWIG_null_ref("wxEvent");
15506 }
15507 if (SWIG_arg_fail(2)) SWIG_fail;
15508 }
15509 {
15510 PyThreadState* __tstate = wxPyBeginAllowThreads();
15511 result = (bool)(arg1)->ProcessEvent(*arg2);
15512
15513 wxPyEndAllowThreads(__tstate);
15514 if (PyErr_Occurred()) SWIG_fail;
15515 }
15516 {
15517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15518 }
15519 return resultobj;
15520 fail:
15521 return NULL;
15522 }
15523
15524
15525 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15526 PyObject *resultobj = NULL;
15527 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15528 wxEvent *arg2 = 0 ;
15529 PyObject * obj0 = 0 ;
15530 PyObject * obj1 = 0 ;
15531 char *kwnames[] = {
15532 (char *) "self",(char *) "event", NULL
15533 };
15534
15535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
15536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15537 if (SWIG_arg_fail(1)) SWIG_fail;
15538 {
15539 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15540 if (SWIG_arg_fail(2)) SWIG_fail;
15541 if (arg2 == NULL) {
15542 SWIG_null_ref("wxEvent");
15543 }
15544 if (SWIG_arg_fail(2)) SWIG_fail;
15545 }
15546 {
15547 PyThreadState* __tstate = wxPyBeginAllowThreads();
15548 (arg1)->AddPendingEvent(*arg2);
15549
15550 wxPyEndAllowThreads(__tstate);
15551 if (PyErr_Occurred()) SWIG_fail;
15552 }
15553 Py_INCREF(Py_None); resultobj = Py_None;
15554 return resultobj;
15555 fail:
15556 return NULL;
15557 }
15558
15559
15560 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
15561 PyObject *resultobj = NULL;
15562 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15563 PyObject * obj0 = 0 ;
15564 char *kwnames[] = {
15565 (char *) "self", NULL
15566 };
15567
15568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
15569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15570 if (SWIG_arg_fail(1)) SWIG_fail;
15571 {
15572 PyThreadState* __tstate = wxPyBeginAllowThreads();
15573 (arg1)->ProcessPendingEvents();
15574
15575 wxPyEndAllowThreads(__tstate);
15576 if (PyErr_Occurred()) SWIG_fail;
15577 }
15578 Py_INCREF(Py_None); resultobj = Py_None;
15579 return resultobj;
15580 fail:
15581 return NULL;
15582 }
15583
15584
15585 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
15586 PyObject *resultobj = NULL;
15587 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15588 int arg2 ;
15589 int arg3 ;
15590 int arg4 ;
15591 PyObject *arg5 = (PyObject *) 0 ;
15592 PyObject * obj0 = 0 ;
15593 PyObject * obj1 = 0 ;
15594 PyObject * obj2 = 0 ;
15595 PyObject * obj3 = 0 ;
15596 PyObject * obj4 = 0 ;
15597 char *kwnames[] = {
15598 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
15599 };
15600
15601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15603 if (SWIG_arg_fail(1)) SWIG_fail;
15604 {
15605 arg2 = static_cast<int >(SWIG_As_int(obj1));
15606 if (SWIG_arg_fail(2)) SWIG_fail;
15607 }
15608 {
15609 arg3 = static_cast<int >(SWIG_As_int(obj2));
15610 if (SWIG_arg_fail(3)) SWIG_fail;
15611 }
15612 {
15613 arg4 = static_cast<int >(SWIG_As_int(obj3));
15614 if (SWIG_arg_fail(4)) SWIG_fail;
15615 }
15616 arg5 = obj4;
15617 {
15618 PyThreadState* __tstate = wxPyBeginAllowThreads();
15619 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
15620
15621 wxPyEndAllowThreads(__tstate);
15622 if (PyErr_Occurred()) SWIG_fail;
15623 }
15624 Py_INCREF(Py_None); resultobj = Py_None;
15625 return resultobj;
15626 fail:
15627 return NULL;
15628 }
15629
15630
15631 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
15632 PyObject *resultobj = NULL;
15633 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15634 int arg2 ;
15635 int arg3 = (int) -1 ;
15636 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
15637 bool result;
15638 PyObject * obj0 = 0 ;
15639 PyObject * obj1 = 0 ;
15640 PyObject * obj2 = 0 ;
15641 PyObject * obj3 = 0 ;
15642 char *kwnames[] = {
15643 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
15644 };
15645
15646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15648 if (SWIG_arg_fail(1)) SWIG_fail;
15649 {
15650 arg2 = static_cast<int >(SWIG_As_int(obj1));
15651 if (SWIG_arg_fail(2)) SWIG_fail;
15652 }
15653 if (obj2) {
15654 {
15655 arg3 = static_cast<int >(SWIG_As_int(obj2));
15656 if (SWIG_arg_fail(3)) SWIG_fail;
15657 }
15658 }
15659 if (obj3) {
15660 {
15661 arg4 = static_cast<wxEventType >(SWIG_As_int(obj3));
15662 if (SWIG_arg_fail(4)) SWIG_fail;
15663 }
15664 }
15665 {
15666 PyThreadState* __tstate = wxPyBeginAllowThreads();
15667 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
15668
15669 wxPyEndAllowThreads(__tstate);
15670 if (PyErr_Occurred()) SWIG_fail;
15671 }
15672 {
15673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15674 }
15675 return resultobj;
15676 fail:
15677 return NULL;
15678 }
15679
15680
15681 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
15682 PyObject *resultobj = NULL;
15683 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15684 PyObject *arg2 = (PyObject *) 0 ;
15685 bool arg3 = (bool) true ;
15686 PyObject * obj0 = 0 ;
15687 PyObject * obj1 = 0 ;
15688 PyObject * obj2 = 0 ;
15689 char *kwnames[] = {
15690 (char *) "self",(char *) "_self",(char *) "incref", NULL
15691 };
15692
15693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
15694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15695 if (SWIG_arg_fail(1)) SWIG_fail;
15696 arg2 = obj1;
15697 if (obj2) {
15698 {
15699 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
15700 if (SWIG_arg_fail(3)) SWIG_fail;
15701 }
15702 }
15703 {
15704 PyThreadState* __tstate = wxPyBeginAllowThreads();
15705 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
15706
15707 wxPyEndAllowThreads(__tstate);
15708 if (PyErr_Occurred()) SWIG_fail;
15709 }
15710 Py_INCREF(Py_None); resultobj = Py_None;
15711 return resultobj;
15712 fail:
15713 return NULL;
15714 }
15715
15716
15717 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
15718 PyObject *obj;
15719 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15720 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
15721 Py_INCREF(obj);
15722 return Py_BuildValue((char *)"");
15723 }
15724 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15725 PyObject *resultobj = NULL;
15726 wxEventType result;
15727 char *kwnames[] = {
15728 NULL
15729 };
15730
15731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
15732 {
15733 PyThreadState* __tstate = wxPyBeginAllowThreads();
15734 result = (wxEventType)wxNewEventType();
15735
15736 wxPyEndAllowThreads(__tstate);
15737 if (PyErr_Occurred()) SWIG_fail;
15738 }
15739 {
15740 resultobj = SWIG_From_int(static_cast<int >(result));
15741 }
15742 return resultobj;
15743 fail:
15744 return NULL;
15745 }
15746
15747
15748 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
15749 PyObject *resultobj = NULL;
15750 wxEvent *arg1 = (wxEvent *) 0 ;
15751 PyObject * obj0 = 0 ;
15752 char *kwnames[] = {
15753 (char *) "self", NULL
15754 };
15755
15756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
15757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15758 if (SWIG_arg_fail(1)) SWIG_fail;
15759 {
15760 PyThreadState* __tstate = wxPyBeginAllowThreads();
15761 delete arg1;
15762
15763 wxPyEndAllowThreads(__tstate);
15764 if (PyErr_Occurred()) SWIG_fail;
15765 }
15766 Py_INCREF(Py_None); resultobj = Py_None;
15767 return resultobj;
15768 fail:
15769 return NULL;
15770 }
15771
15772
15773 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15774 PyObject *resultobj = NULL;
15775 wxEvent *arg1 = (wxEvent *) 0 ;
15776 wxEventType arg2 ;
15777 PyObject * obj0 = 0 ;
15778 PyObject * obj1 = 0 ;
15779 char *kwnames[] = {
15780 (char *) "self",(char *) "typ", NULL
15781 };
15782
15783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15785 if (SWIG_arg_fail(1)) SWIG_fail;
15786 {
15787 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
15788 if (SWIG_arg_fail(2)) SWIG_fail;
15789 }
15790 {
15791 PyThreadState* __tstate = wxPyBeginAllowThreads();
15792 (arg1)->SetEventType(arg2);
15793
15794 wxPyEndAllowThreads(__tstate);
15795 if (PyErr_Occurred()) SWIG_fail;
15796 }
15797 Py_INCREF(Py_None); resultobj = Py_None;
15798 return resultobj;
15799 fail:
15800 return NULL;
15801 }
15802
15803
15804 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15805 PyObject *resultobj = NULL;
15806 wxEvent *arg1 = (wxEvent *) 0 ;
15807 wxEventType result;
15808 PyObject * obj0 = 0 ;
15809 char *kwnames[] = {
15810 (char *) "self", NULL
15811 };
15812
15813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15815 if (SWIG_arg_fail(1)) SWIG_fail;
15816 {
15817 PyThreadState* __tstate = wxPyBeginAllowThreads();
15818 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15819
15820 wxPyEndAllowThreads(__tstate);
15821 if (PyErr_Occurred()) SWIG_fail;
15822 }
15823 {
15824 resultobj = SWIG_From_int(static_cast<int >(result));
15825 }
15826 return resultobj;
15827 fail:
15828 return NULL;
15829 }
15830
15831
15832 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15833 PyObject *resultobj = NULL;
15834 wxEvent *arg1 = (wxEvent *) 0 ;
15835 wxObject *result;
15836 PyObject * obj0 = 0 ;
15837 char *kwnames[] = {
15838 (char *) "self", NULL
15839 };
15840
15841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15843 if (SWIG_arg_fail(1)) SWIG_fail;
15844 {
15845 PyThreadState* __tstate = wxPyBeginAllowThreads();
15846 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15847
15848 wxPyEndAllowThreads(__tstate);
15849 if (PyErr_Occurred()) SWIG_fail;
15850 }
15851 {
15852 resultobj = wxPyMake_wxObject(result, 0);
15853 }
15854 return resultobj;
15855 fail:
15856 return NULL;
15857 }
15858
15859
15860 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15861 PyObject *resultobj = NULL;
15862 wxEvent *arg1 = (wxEvent *) 0 ;
15863 wxObject *arg2 = (wxObject *) 0 ;
15864 PyObject * obj0 = 0 ;
15865 PyObject * obj1 = 0 ;
15866 char *kwnames[] = {
15867 (char *) "self",(char *) "obj", NULL
15868 };
15869
15870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15872 if (SWIG_arg_fail(1)) SWIG_fail;
15873 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15874 if (SWIG_arg_fail(2)) SWIG_fail;
15875 {
15876 PyThreadState* __tstate = wxPyBeginAllowThreads();
15877 (arg1)->SetEventObject(arg2);
15878
15879 wxPyEndAllowThreads(__tstate);
15880 if (PyErr_Occurred()) SWIG_fail;
15881 }
15882 Py_INCREF(Py_None); resultobj = Py_None;
15883 return resultobj;
15884 fail:
15885 return NULL;
15886 }
15887
15888
15889 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15890 PyObject *resultobj = NULL;
15891 wxEvent *arg1 = (wxEvent *) 0 ;
15892 long result;
15893 PyObject * obj0 = 0 ;
15894 char *kwnames[] = {
15895 (char *) "self", NULL
15896 };
15897
15898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15900 if (SWIG_arg_fail(1)) SWIG_fail;
15901 {
15902 PyThreadState* __tstate = wxPyBeginAllowThreads();
15903 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15904
15905 wxPyEndAllowThreads(__tstate);
15906 if (PyErr_Occurred()) SWIG_fail;
15907 }
15908 {
15909 resultobj = SWIG_From_long(static_cast<long >(result));
15910 }
15911 return resultobj;
15912 fail:
15913 return NULL;
15914 }
15915
15916
15917 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15918 PyObject *resultobj = NULL;
15919 wxEvent *arg1 = (wxEvent *) 0 ;
15920 long arg2 = (long) 0 ;
15921 PyObject * obj0 = 0 ;
15922 PyObject * obj1 = 0 ;
15923 char *kwnames[] = {
15924 (char *) "self",(char *) "ts", NULL
15925 };
15926
15927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15929 if (SWIG_arg_fail(1)) SWIG_fail;
15930 if (obj1) {
15931 {
15932 arg2 = static_cast<long >(SWIG_As_long(obj1));
15933 if (SWIG_arg_fail(2)) SWIG_fail;
15934 }
15935 }
15936 {
15937 PyThreadState* __tstate = wxPyBeginAllowThreads();
15938 (arg1)->SetTimestamp(arg2);
15939
15940 wxPyEndAllowThreads(__tstate);
15941 if (PyErr_Occurred()) SWIG_fail;
15942 }
15943 Py_INCREF(Py_None); resultobj = Py_None;
15944 return resultobj;
15945 fail:
15946 return NULL;
15947 }
15948
15949
15950 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15951 PyObject *resultobj = NULL;
15952 wxEvent *arg1 = (wxEvent *) 0 ;
15953 int result;
15954 PyObject * obj0 = 0 ;
15955 char *kwnames[] = {
15956 (char *) "self", NULL
15957 };
15958
15959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15961 if (SWIG_arg_fail(1)) SWIG_fail;
15962 {
15963 PyThreadState* __tstate = wxPyBeginAllowThreads();
15964 result = (int)((wxEvent const *)arg1)->GetId();
15965
15966 wxPyEndAllowThreads(__tstate);
15967 if (PyErr_Occurred()) SWIG_fail;
15968 }
15969 {
15970 resultobj = SWIG_From_int(static_cast<int >(result));
15971 }
15972 return resultobj;
15973 fail:
15974 return NULL;
15975 }
15976
15977
15978 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15979 PyObject *resultobj = NULL;
15980 wxEvent *arg1 = (wxEvent *) 0 ;
15981 int arg2 ;
15982 PyObject * obj0 = 0 ;
15983 PyObject * obj1 = 0 ;
15984 char *kwnames[] = {
15985 (char *) "self",(char *) "Id", NULL
15986 };
15987
15988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15990 if (SWIG_arg_fail(1)) SWIG_fail;
15991 {
15992 arg2 = static_cast<int >(SWIG_As_int(obj1));
15993 if (SWIG_arg_fail(2)) SWIG_fail;
15994 }
15995 {
15996 PyThreadState* __tstate = wxPyBeginAllowThreads();
15997 (arg1)->SetId(arg2);
15998
15999 wxPyEndAllowThreads(__tstate);
16000 if (PyErr_Occurred()) SWIG_fail;
16001 }
16002 Py_INCREF(Py_None); resultobj = Py_None;
16003 return resultobj;
16004 fail:
16005 return NULL;
16006 }
16007
16008
16009 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16010 PyObject *resultobj = NULL;
16011 wxEvent *arg1 = (wxEvent *) 0 ;
16012 bool result;
16013 PyObject * obj0 = 0 ;
16014 char *kwnames[] = {
16015 (char *) "self", NULL
16016 };
16017
16018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
16019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16020 if (SWIG_arg_fail(1)) SWIG_fail;
16021 {
16022 PyThreadState* __tstate = wxPyBeginAllowThreads();
16023 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
16024
16025 wxPyEndAllowThreads(__tstate);
16026 if (PyErr_Occurred()) SWIG_fail;
16027 }
16028 {
16029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16030 }
16031 return resultobj;
16032 fail:
16033 return NULL;
16034 }
16035
16036
16037 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
16038 PyObject *resultobj = NULL;
16039 wxEvent *arg1 = (wxEvent *) 0 ;
16040 bool arg2 = (bool) true ;
16041 PyObject * obj0 = 0 ;
16042 PyObject * obj1 = 0 ;
16043 char *kwnames[] = {
16044 (char *) "self",(char *) "skip", NULL
16045 };
16046
16047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
16048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16049 if (SWIG_arg_fail(1)) SWIG_fail;
16050 if (obj1) {
16051 {
16052 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
16053 if (SWIG_arg_fail(2)) SWIG_fail;
16054 }
16055 }
16056 {
16057 PyThreadState* __tstate = wxPyBeginAllowThreads();
16058 (arg1)->Skip(arg2);
16059
16060 wxPyEndAllowThreads(__tstate);
16061 if (PyErr_Occurred()) SWIG_fail;
16062 }
16063 Py_INCREF(Py_None); resultobj = Py_None;
16064 return resultobj;
16065 fail:
16066 return NULL;
16067 }
16068
16069
16070 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
16071 PyObject *resultobj = NULL;
16072 wxEvent *arg1 = (wxEvent *) 0 ;
16073 bool result;
16074 PyObject * obj0 = 0 ;
16075 char *kwnames[] = {
16076 (char *) "self", NULL
16077 };
16078
16079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
16080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16081 if (SWIG_arg_fail(1)) SWIG_fail;
16082 {
16083 PyThreadState* __tstate = wxPyBeginAllowThreads();
16084 result = (bool)((wxEvent const *)arg1)->GetSkipped();
16085
16086 wxPyEndAllowThreads(__tstate);
16087 if (PyErr_Occurred()) SWIG_fail;
16088 }
16089 {
16090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16091 }
16092 return resultobj;
16093 fail:
16094 return NULL;
16095 }
16096
16097
16098 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
16099 PyObject *resultobj = NULL;
16100 wxEvent *arg1 = (wxEvent *) 0 ;
16101 bool result;
16102 PyObject * obj0 = 0 ;
16103 char *kwnames[] = {
16104 (char *) "self", NULL
16105 };
16106
16107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
16108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16109 if (SWIG_arg_fail(1)) SWIG_fail;
16110 {
16111 PyThreadState* __tstate = wxPyBeginAllowThreads();
16112 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
16113
16114 wxPyEndAllowThreads(__tstate);
16115 if (PyErr_Occurred()) SWIG_fail;
16116 }
16117 {
16118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16119 }
16120 return resultobj;
16121 fail:
16122 return NULL;
16123 }
16124
16125
16126 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
16127 PyObject *resultobj = NULL;
16128 wxEvent *arg1 = (wxEvent *) 0 ;
16129 int result;
16130 PyObject * obj0 = 0 ;
16131 char *kwnames[] = {
16132 (char *) "self", NULL
16133 };
16134
16135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
16136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16137 if (SWIG_arg_fail(1)) SWIG_fail;
16138 {
16139 PyThreadState* __tstate = wxPyBeginAllowThreads();
16140 result = (int)(arg1)->StopPropagation();
16141
16142 wxPyEndAllowThreads(__tstate);
16143 if (PyErr_Occurred()) SWIG_fail;
16144 }
16145 {
16146 resultobj = SWIG_From_int(static_cast<int >(result));
16147 }
16148 return resultobj;
16149 fail:
16150 return NULL;
16151 }
16152
16153
16154 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
16155 PyObject *resultobj = NULL;
16156 wxEvent *arg1 = (wxEvent *) 0 ;
16157 int arg2 ;
16158 PyObject * obj0 = 0 ;
16159 PyObject * obj1 = 0 ;
16160 char *kwnames[] = {
16161 (char *) "self",(char *) "propagationLevel", NULL
16162 };
16163
16164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
16165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16166 if (SWIG_arg_fail(1)) SWIG_fail;
16167 {
16168 arg2 = static_cast<int >(SWIG_As_int(obj1));
16169 if (SWIG_arg_fail(2)) SWIG_fail;
16170 }
16171 {
16172 PyThreadState* __tstate = wxPyBeginAllowThreads();
16173 (arg1)->ResumePropagation(arg2);
16174
16175 wxPyEndAllowThreads(__tstate);
16176 if (PyErr_Occurred()) SWIG_fail;
16177 }
16178 Py_INCREF(Py_None); resultobj = Py_None;
16179 return resultobj;
16180 fail:
16181 return NULL;
16182 }
16183
16184
16185 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16186 PyObject *resultobj = NULL;
16187 wxEvent *arg1 = (wxEvent *) 0 ;
16188 wxEvent *result;
16189 PyObject * obj0 = 0 ;
16190 char *kwnames[] = {
16191 (char *) "self", NULL
16192 };
16193
16194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
16195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16196 if (SWIG_arg_fail(1)) SWIG_fail;
16197 {
16198 PyThreadState* __tstate = wxPyBeginAllowThreads();
16199 result = (wxEvent *)(arg1)->Clone();
16200
16201 wxPyEndAllowThreads(__tstate);
16202 if (PyErr_Occurred()) SWIG_fail;
16203 }
16204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16205 return resultobj;
16206 fail:
16207 return NULL;
16208 }
16209
16210
16211 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
16212 PyObject *obj;
16213 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16214 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
16215 Py_INCREF(obj);
16216 return Py_BuildValue((char *)"");
16217 }
16218 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16219 PyObject *resultobj = NULL;
16220 wxEvent *arg1 = 0 ;
16221 wxPropagationDisabler *result;
16222 PyObject * obj0 = 0 ;
16223 char *kwnames[] = {
16224 (char *) "event", NULL
16225 };
16226
16227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
16228 {
16229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16230 if (SWIG_arg_fail(1)) SWIG_fail;
16231 if (arg1 == NULL) {
16232 SWIG_null_ref("wxEvent");
16233 }
16234 if (SWIG_arg_fail(1)) SWIG_fail;
16235 }
16236 {
16237 PyThreadState* __tstate = wxPyBeginAllowThreads();
16238 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
16239
16240 wxPyEndAllowThreads(__tstate);
16241 if (PyErr_Occurred()) SWIG_fail;
16242 }
16243 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
16244 return resultobj;
16245 fail:
16246 return NULL;
16247 }
16248
16249
16250 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16251 PyObject *resultobj = NULL;
16252 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
16253 PyObject * obj0 = 0 ;
16254 char *kwnames[] = {
16255 (char *) "self", NULL
16256 };
16257
16258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
16259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
16260 if (SWIG_arg_fail(1)) SWIG_fail;
16261 {
16262 PyThreadState* __tstate = wxPyBeginAllowThreads();
16263 delete arg1;
16264
16265 wxPyEndAllowThreads(__tstate);
16266 if (PyErr_Occurred()) SWIG_fail;
16267 }
16268 Py_INCREF(Py_None); resultobj = Py_None;
16269 return resultobj;
16270 fail:
16271 return NULL;
16272 }
16273
16274
16275 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
16276 PyObject *obj;
16277 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16278 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
16279 Py_INCREF(obj);
16280 return Py_BuildValue((char *)"");
16281 }
16282 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16283 PyObject *resultobj = NULL;
16284 wxEvent *arg1 = 0 ;
16285 wxPropagateOnce *result;
16286 PyObject * obj0 = 0 ;
16287 char *kwnames[] = {
16288 (char *) "event", NULL
16289 };
16290
16291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
16292 {
16293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16294 if (SWIG_arg_fail(1)) SWIG_fail;
16295 if (arg1 == NULL) {
16296 SWIG_null_ref("wxEvent");
16297 }
16298 if (SWIG_arg_fail(1)) SWIG_fail;
16299 }
16300 {
16301 PyThreadState* __tstate = wxPyBeginAllowThreads();
16302 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
16303
16304 wxPyEndAllowThreads(__tstate);
16305 if (PyErr_Occurred()) SWIG_fail;
16306 }
16307 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
16308 return resultobj;
16309 fail:
16310 return NULL;
16311 }
16312
16313
16314 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16315 PyObject *resultobj = NULL;
16316 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
16317 PyObject * obj0 = 0 ;
16318 char *kwnames[] = {
16319 (char *) "self", NULL
16320 };
16321
16322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
16323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
16324 if (SWIG_arg_fail(1)) SWIG_fail;
16325 {
16326 PyThreadState* __tstate = wxPyBeginAllowThreads();
16327 delete arg1;
16328
16329 wxPyEndAllowThreads(__tstate);
16330 if (PyErr_Occurred()) SWIG_fail;
16331 }
16332 Py_INCREF(Py_None); resultobj = Py_None;
16333 return resultobj;
16334 fail:
16335 return NULL;
16336 }
16337
16338
16339 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
16340 PyObject *obj;
16341 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16342 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
16343 Py_INCREF(obj);
16344 return Py_BuildValue((char *)"");
16345 }
16346 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16347 PyObject *resultobj = NULL;
16348 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16349 int arg2 = (int) 0 ;
16350 wxCommandEvent *result;
16351 PyObject * obj0 = 0 ;
16352 PyObject * obj1 = 0 ;
16353 char *kwnames[] = {
16354 (char *) "commandType",(char *) "winid", NULL
16355 };
16356
16357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
16358 if (obj0) {
16359 {
16360 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16361 if (SWIG_arg_fail(1)) SWIG_fail;
16362 }
16363 }
16364 if (obj1) {
16365 {
16366 arg2 = static_cast<int >(SWIG_As_int(obj1));
16367 if (SWIG_arg_fail(2)) SWIG_fail;
16368 }
16369 }
16370 {
16371 PyThreadState* __tstate = wxPyBeginAllowThreads();
16372 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
16373
16374 wxPyEndAllowThreads(__tstate);
16375 if (PyErr_Occurred()) SWIG_fail;
16376 }
16377 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
16378 return resultobj;
16379 fail:
16380 return NULL;
16381 }
16382
16383
16384 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16385 PyObject *resultobj = NULL;
16386 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16387 int result;
16388 PyObject * obj0 = 0 ;
16389 char *kwnames[] = {
16390 (char *) "self", NULL
16391 };
16392
16393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
16394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16395 if (SWIG_arg_fail(1)) SWIG_fail;
16396 {
16397 PyThreadState* __tstate = wxPyBeginAllowThreads();
16398 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
16399
16400 wxPyEndAllowThreads(__tstate);
16401 if (PyErr_Occurred()) SWIG_fail;
16402 }
16403 {
16404 resultobj = SWIG_From_int(static_cast<int >(result));
16405 }
16406 return resultobj;
16407 fail:
16408 return NULL;
16409 }
16410
16411
16412 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
16413 PyObject *resultobj = NULL;
16414 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16415 wxString *arg2 = 0 ;
16416 bool temp2 = false ;
16417 PyObject * obj0 = 0 ;
16418 PyObject * obj1 = 0 ;
16419 char *kwnames[] = {
16420 (char *) "self",(char *) "s", NULL
16421 };
16422
16423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
16424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16425 if (SWIG_arg_fail(1)) SWIG_fail;
16426 {
16427 arg2 = wxString_in_helper(obj1);
16428 if (arg2 == NULL) SWIG_fail;
16429 temp2 = true;
16430 }
16431 {
16432 PyThreadState* __tstate = wxPyBeginAllowThreads();
16433 (arg1)->SetString((wxString const &)*arg2);
16434
16435 wxPyEndAllowThreads(__tstate);
16436 if (PyErr_Occurred()) SWIG_fail;
16437 }
16438 Py_INCREF(Py_None); resultobj = Py_None;
16439 {
16440 if (temp2)
16441 delete arg2;
16442 }
16443 return resultobj;
16444 fail:
16445 {
16446 if (temp2)
16447 delete arg2;
16448 }
16449 return NULL;
16450 }
16451
16452
16453 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
16454 PyObject *resultobj = NULL;
16455 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16456 wxString result;
16457 PyObject * obj0 = 0 ;
16458 char *kwnames[] = {
16459 (char *) "self", NULL
16460 };
16461
16462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
16463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16464 if (SWIG_arg_fail(1)) SWIG_fail;
16465 {
16466 PyThreadState* __tstate = wxPyBeginAllowThreads();
16467 result = ((wxCommandEvent const *)arg1)->GetString();
16468
16469 wxPyEndAllowThreads(__tstate);
16470 if (PyErr_Occurred()) SWIG_fail;
16471 }
16472 {
16473 #if wxUSE_UNICODE
16474 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16475 #else
16476 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16477 #endif
16478 }
16479 return resultobj;
16480 fail:
16481 return NULL;
16482 }
16483
16484
16485 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
16486 PyObject *resultobj = NULL;
16487 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16488 bool result;
16489 PyObject * obj0 = 0 ;
16490 char *kwnames[] = {
16491 (char *) "self", NULL
16492 };
16493
16494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
16495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16496 if (SWIG_arg_fail(1)) SWIG_fail;
16497 {
16498 PyThreadState* __tstate = wxPyBeginAllowThreads();
16499 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
16500
16501 wxPyEndAllowThreads(__tstate);
16502 if (PyErr_Occurred()) SWIG_fail;
16503 }
16504 {
16505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16506 }
16507 return resultobj;
16508 fail:
16509 return NULL;
16510 }
16511
16512
16513 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16514 PyObject *resultobj = NULL;
16515 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16516 bool result;
16517 PyObject * obj0 = 0 ;
16518 char *kwnames[] = {
16519 (char *) "self", NULL
16520 };
16521
16522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
16523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16524 if (SWIG_arg_fail(1)) SWIG_fail;
16525 {
16526 PyThreadState* __tstate = wxPyBeginAllowThreads();
16527 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
16528
16529 wxPyEndAllowThreads(__tstate);
16530 if (PyErr_Occurred()) SWIG_fail;
16531 }
16532 {
16533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16534 }
16535 return resultobj;
16536 fail:
16537 return NULL;
16538 }
16539
16540
16541 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16542 PyObject *resultobj = NULL;
16543 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16544 long arg2 ;
16545 PyObject * obj0 = 0 ;
16546 PyObject * obj1 = 0 ;
16547 char *kwnames[] = {
16548 (char *) "self",(char *) "extraLong", NULL
16549 };
16550
16551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
16552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16553 if (SWIG_arg_fail(1)) SWIG_fail;
16554 {
16555 arg2 = static_cast<long >(SWIG_As_long(obj1));
16556 if (SWIG_arg_fail(2)) SWIG_fail;
16557 }
16558 {
16559 PyThreadState* __tstate = wxPyBeginAllowThreads();
16560 (arg1)->SetExtraLong(arg2);
16561
16562 wxPyEndAllowThreads(__tstate);
16563 if (PyErr_Occurred()) SWIG_fail;
16564 }
16565 Py_INCREF(Py_None); resultobj = Py_None;
16566 return resultobj;
16567 fail:
16568 return NULL;
16569 }
16570
16571
16572 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16573 PyObject *resultobj = NULL;
16574 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16575 long result;
16576 PyObject * obj0 = 0 ;
16577 char *kwnames[] = {
16578 (char *) "self", NULL
16579 };
16580
16581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
16582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16583 if (SWIG_arg_fail(1)) SWIG_fail;
16584 {
16585 PyThreadState* __tstate = wxPyBeginAllowThreads();
16586 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
16587
16588 wxPyEndAllowThreads(__tstate);
16589 if (PyErr_Occurred()) SWIG_fail;
16590 }
16591 {
16592 resultobj = SWIG_From_long(static_cast<long >(result));
16593 }
16594 return resultobj;
16595 fail:
16596 return NULL;
16597 }
16598
16599
16600 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16601 PyObject *resultobj = NULL;
16602 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16603 int arg2 ;
16604 PyObject * obj0 = 0 ;
16605 PyObject * obj1 = 0 ;
16606 char *kwnames[] = {
16607 (char *) "self",(char *) "i", NULL
16608 };
16609
16610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
16611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16612 if (SWIG_arg_fail(1)) SWIG_fail;
16613 {
16614 arg2 = static_cast<int >(SWIG_As_int(obj1));
16615 if (SWIG_arg_fail(2)) SWIG_fail;
16616 }
16617 {
16618 PyThreadState* __tstate = wxPyBeginAllowThreads();
16619 (arg1)->SetInt(arg2);
16620
16621 wxPyEndAllowThreads(__tstate);
16622 if (PyErr_Occurred()) SWIG_fail;
16623 }
16624 Py_INCREF(Py_None); resultobj = Py_None;
16625 return resultobj;
16626 fail:
16627 return NULL;
16628 }
16629
16630
16631 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16632 PyObject *resultobj = NULL;
16633 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16634 long result;
16635 PyObject * obj0 = 0 ;
16636 char *kwnames[] = {
16637 (char *) "self", NULL
16638 };
16639
16640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
16641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16642 if (SWIG_arg_fail(1)) SWIG_fail;
16643 {
16644 PyThreadState* __tstate = wxPyBeginAllowThreads();
16645 result = (long)((wxCommandEvent const *)arg1)->GetInt();
16646
16647 wxPyEndAllowThreads(__tstate);
16648 if (PyErr_Occurred()) SWIG_fail;
16649 }
16650 {
16651 resultobj = SWIG_From_long(static_cast<long >(result));
16652 }
16653 return resultobj;
16654 fail:
16655 return NULL;
16656 }
16657
16658
16659 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16660 PyObject *resultobj = NULL;
16661 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16662 wxEvent *result;
16663 PyObject * obj0 = 0 ;
16664 char *kwnames[] = {
16665 (char *) "self", NULL
16666 };
16667
16668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
16669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16670 if (SWIG_arg_fail(1)) SWIG_fail;
16671 {
16672 PyThreadState* __tstate = wxPyBeginAllowThreads();
16673 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
16674
16675 wxPyEndAllowThreads(__tstate);
16676 if (PyErr_Occurred()) SWIG_fail;
16677 }
16678 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16679 return resultobj;
16680 fail:
16681 return NULL;
16682 }
16683
16684
16685 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
16686 PyObject *obj;
16687 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16688 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
16689 Py_INCREF(obj);
16690 return Py_BuildValue((char *)"");
16691 }
16692 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16693 PyObject *resultobj = NULL;
16694 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16695 int arg2 = (int) 0 ;
16696 wxNotifyEvent *result;
16697 PyObject * obj0 = 0 ;
16698 PyObject * obj1 = 0 ;
16699 char *kwnames[] = {
16700 (char *) "commandType",(char *) "winid", NULL
16701 };
16702
16703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
16704 if (obj0) {
16705 {
16706 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16707 if (SWIG_arg_fail(1)) SWIG_fail;
16708 }
16709 }
16710 if (obj1) {
16711 {
16712 arg2 = static_cast<int >(SWIG_As_int(obj1));
16713 if (SWIG_arg_fail(2)) SWIG_fail;
16714 }
16715 }
16716 {
16717 PyThreadState* __tstate = wxPyBeginAllowThreads();
16718 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
16719
16720 wxPyEndAllowThreads(__tstate);
16721 if (PyErr_Occurred()) SWIG_fail;
16722 }
16723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
16724 return resultobj;
16725 fail:
16726 return NULL;
16727 }
16728
16729
16730 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
16731 PyObject *resultobj = NULL;
16732 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16733 PyObject * obj0 = 0 ;
16734 char *kwnames[] = {
16735 (char *) "self", NULL
16736 };
16737
16738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
16739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16740 if (SWIG_arg_fail(1)) SWIG_fail;
16741 {
16742 PyThreadState* __tstate = wxPyBeginAllowThreads();
16743 (arg1)->Veto();
16744
16745 wxPyEndAllowThreads(__tstate);
16746 if (PyErr_Occurred()) SWIG_fail;
16747 }
16748 Py_INCREF(Py_None); resultobj = Py_None;
16749 return resultobj;
16750 fail:
16751 return NULL;
16752 }
16753
16754
16755 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
16756 PyObject *resultobj = NULL;
16757 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16758 PyObject * obj0 = 0 ;
16759 char *kwnames[] = {
16760 (char *) "self", NULL
16761 };
16762
16763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16765 if (SWIG_arg_fail(1)) SWIG_fail;
16766 {
16767 PyThreadState* __tstate = wxPyBeginAllowThreads();
16768 (arg1)->Allow();
16769
16770 wxPyEndAllowThreads(__tstate);
16771 if (PyErr_Occurred()) SWIG_fail;
16772 }
16773 Py_INCREF(Py_None); resultobj = Py_None;
16774 return resultobj;
16775 fail:
16776 return NULL;
16777 }
16778
16779
16780 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16781 PyObject *resultobj = NULL;
16782 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16783 bool result;
16784 PyObject * obj0 = 0 ;
16785 char *kwnames[] = {
16786 (char *) "self", NULL
16787 };
16788
16789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16791 if (SWIG_arg_fail(1)) SWIG_fail;
16792 {
16793 PyThreadState* __tstate = wxPyBeginAllowThreads();
16794 result = (bool)(arg1)->IsAllowed();
16795
16796 wxPyEndAllowThreads(__tstate);
16797 if (PyErr_Occurred()) SWIG_fail;
16798 }
16799 {
16800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16801 }
16802 return resultobj;
16803 fail:
16804 return NULL;
16805 }
16806
16807
16808 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16809 PyObject *obj;
16810 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16811 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16812 Py_INCREF(obj);
16813 return Py_BuildValue((char *)"");
16814 }
16815 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16816 PyObject *resultobj = NULL;
16817 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16818 int arg2 = (int) 0 ;
16819 int arg3 = (int) 0 ;
16820 int arg4 = (int) 0 ;
16821 wxScrollEvent *result;
16822 PyObject * obj0 = 0 ;
16823 PyObject * obj1 = 0 ;
16824 PyObject * obj2 = 0 ;
16825 PyObject * obj3 = 0 ;
16826 char *kwnames[] = {
16827 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16828 };
16829
16830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16831 if (obj0) {
16832 {
16833 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16834 if (SWIG_arg_fail(1)) SWIG_fail;
16835 }
16836 }
16837 if (obj1) {
16838 {
16839 arg2 = static_cast<int >(SWIG_As_int(obj1));
16840 if (SWIG_arg_fail(2)) SWIG_fail;
16841 }
16842 }
16843 if (obj2) {
16844 {
16845 arg3 = static_cast<int >(SWIG_As_int(obj2));
16846 if (SWIG_arg_fail(3)) SWIG_fail;
16847 }
16848 }
16849 if (obj3) {
16850 {
16851 arg4 = static_cast<int >(SWIG_As_int(obj3));
16852 if (SWIG_arg_fail(4)) SWIG_fail;
16853 }
16854 }
16855 {
16856 PyThreadState* __tstate = wxPyBeginAllowThreads();
16857 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16858
16859 wxPyEndAllowThreads(__tstate);
16860 if (PyErr_Occurred()) SWIG_fail;
16861 }
16862 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16863 return resultobj;
16864 fail:
16865 return NULL;
16866 }
16867
16868
16869 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16870 PyObject *resultobj = NULL;
16871 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16872 int result;
16873 PyObject * obj0 = 0 ;
16874 char *kwnames[] = {
16875 (char *) "self", NULL
16876 };
16877
16878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16880 if (SWIG_arg_fail(1)) SWIG_fail;
16881 {
16882 PyThreadState* __tstate = wxPyBeginAllowThreads();
16883 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16884
16885 wxPyEndAllowThreads(__tstate);
16886 if (PyErr_Occurred()) SWIG_fail;
16887 }
16888 {
16889 resultobj = SWIG_From_int(static_cast<int >(result));
16890 }
16891 return resultobj;
16892 fail:
16893 return NULL;
16894 }
16895
16896
16897 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16898 PyObject *resultobj = NULL;
16899 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16900 int result;
16901 PyObject * obj0 = 0 ;
16902 char *kwnames[] = {
16903 (char *) "self", NULL
16904 };
16905
16906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16908 if (SWIG_arg_fail(1)) SWIG_fail;
16909 {
16910 PyThreadState* __tstate = wxPyBeginAllowThreads();
16911 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16912
16913 wxPyEndAllowThreads(__tstate);
16914 if (PyErr_Occurred()) SWIG_fail;
16915 }
16916 {
16917 resultobj = SWIG_From_int(static_cast<int >(result));
16918 }
16919 return resultobj;
16920 fail:
16921 return NULL;
16922 }
16923
16924
16925 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16926 PyObject *resultobj = NULL;
16927 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16928 int arg2 ;
16929 PyObject * obj0 = 0 ;
16930 PyObject * obj1 = 0 ;
16931 char *kwnames[] = {
16932 (char *) "self",(char *) "orient", NULL
16933 };
16934
16935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16937 if (SWIG_arg_fail(1)) SWIG_fail;
16938 {
16939 arg2 = static_cast<int >(SWIG_As_int(obj1));
16940 if (SWIG_arg_fail(2)) SWIG_fail;
16941 }
16942 {
16943 PyThreadState* __tstate = wxPyBeginAllowThreads();
16944 (arg1)->SetOrientation(arg2);
16945
16946 wxPyEndAllowThreads(__tstate);
16947 if (PyErr_Occurred()) SWIG_fail;
16948 }
16949 Py_INCREF(Py_None); resultobj = Py_None;
16950 return resultobj;
16951 fail:
16952 return NULL;
16953 }
16954
16955
16956 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16957 PyObject *resultobj = NULL;
16958 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16959 int arg2 ;
16960 PyObject * obj0 = 0 ;
16961 PyObject * obj1 = 0 ;
16962 char *kwnames[] = {
16963 (char *) "self",(char *) "pos", NULL
16964 };
16965
16966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16968 if (SWIG_arg_fail(1)) SWIG_fail;
16969 {
16970 arg2 = static_cast<int >(SWIG_As_int(obj1));
16971 if (SWIG_arg_fail(2)) SWIG_fail;
16972 }
16973 {
16974 PyThreadState* __tstate = wxPyBeginAllowThreads();
16975 (arg1)->SetPosition(arg2);
16976
16977 wxPyEndAllowThreads(__tstate);
16978 if (PyErr_Occurred()) SWIG_fail;
16979 }
16980 Py_INCREF(Py_None); resultobj = Py_None;
16981 return resultobj;
16982 fail:
16983 return NULL;
16984 }
16985
16986
16987 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16988 PyObject *obj;
16989 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16990 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16991 Py_INCREF(obj);
16992 return Py_BuildValue((char *)"");
16993 }
16994 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16995 PyObject *resultobj = NULL;
16996 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16997 int arg2 = (int) 0 ;
16998 int arg3 = (int) 0 ;
16999 wxScrollWinEvent *result;
17000 PyObject * obj0 = 0 ;
17001 PyObject * obj1 = 0 ;
17002 PyObject * obj2 = 0 ;
17003 char *kwnames[] = {
17004 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
17005 };
17006
17007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
17008 if (obj0) {
17009 {
17010 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
17011 if (SWIG_arg_fail(1)) SWIG_fail;
17012 }
17013 }
17014 if (obj1) {
17015 {
17016 arg2 = static_cast<int >(SWIG_As_int(obj1));
17017 if (SWIG_arg_fail(2)) SWIG_fail;
17018 }
17019 }
17020 if (obj2) {
17021 {
17022 arg3 = static_cast<int >(SWIG_As_int(obj2));
17023 if (SWIG_arg_fail(3)) SWIG_fail;
17024 }
17025 }
17026 {
17027 PyThreadState* __tstate = wxPyBeginAllowThreads();
17028 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
17029
17030 wxPyEndAllowThreads(__tstate);
17031 if (PyErr_Occurred()) SWIG_fail;
17032 }
17033 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
17034 return resultobj;
17035 fail:
17036 return NULL;
17037 }
17038
17039
17040 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17041 PyObject *resultobj = NULL;
17042 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17043 int result;
17044 PyObject * obj0 = 0 ;
17045 char *kwnames[] = {
17046 (char *) "self", NULL
17047 };
17048
17049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
17050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17051 if (SWIG_arg_fail(1)) SWIG_fail;
17052 {
17053 PyThreadState* __tstate = wxPyBeginAllowThreads();
17054 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
17055
17056 wxPyEndAllowThreads(__tstate);
17057 if (PyErr_Occurred()) SWIG_fail;
17058 }
17059 {
17060 resultobj = SWIG_From_int(static_cast<int >(result));
17061 }
17062 return resultobj;
17063 fail:
17064 return NULL;
17065 }
17066
17067
17068 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17069 PyObject *resultobj = NULL;
17070 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17071 int result;
17072 PyObject * obj0 = 0 ;
17073 char *kwnames[] = {
17074 (char *) "self", NULL
17075 };
17076
17077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
17078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17079 if (SWIG_arg_fail(1)) SWIG_fail;
17080 {
17081 PyThreadState* __tstate = wxPyBeginAllowThreads();
17082 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
17083
17084 wxPyEndAllowThreads(__tstate);
17085 if (PyErr_Occurred()) SWIG_fail;
17086 }
17087 {
17088 resultobj = SWIG_From_int(static_cast<int >(result));
17089 }
17090 return resultobj;
17091 fail:
17092 return NULL;
17093 }
17094
17095
17096 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17097 PyObject *resultobj = NULL;
17098 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17099 int arg2 ;
17100 PyObject * obj0 = 0 ;
17101 PyObject * obj1 = 0 ;
17102 char *kwnames[] = {
17103 (char *) "self",(char *) "orient", NULL
17104 };
17105
17106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
17107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17108 if (SWIG_arg_fail(1)) SWIG_fail;
17109 {
17110 arg2 = static_cast<int >(SWIG_As_int(obj1));
17111 if (SWIG_arg_fail(2)) SWIG_fail;
17112 }
17113 {
17114 PyThreadState* __tstate = wxPyBeginAllowThreads();
17115 (arg1)->SetOrientation(arg2);
17116
17117 wxPyEndAllowThreads(__tstate);
17118 if (PyErr_Occurred()) SWIG_fail;
17119 }
17120 Py_INCREF(Py_None); resultobj = Py_None;
17121 return resultobj;
17122 fail:
17123 return NULL;
17124 }
17125
17126
17127 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17128 PyObject *resultobj = NULL;
17129 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17130 int arg2 ;
17131 PyObject * obj0 = 0 ;
17132 PyObject * obj1 = 0 ;
17133 char *kwnames[] = {
17134 (char *) "self",(char *) "pos", NULL
17135 };
17136
17137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
17138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17139 if (SWIG_arg_fail(1)) SWIG_fail;
17140 {
17141 arg2 = static_cast<int >(SWIG_As_int(obj1));
17142 if (SWIG_arg_fail(2)) SWIG_fail;
17143 }
17144 {
17145 PyThreadState* __tstate = wxPyBeginAllowThreads();
17146 (arg1)->SetPosition(arg2);
17147
17148 wxPyEndAllowThreads(__tstate);
17149 if (PyErr_Occurred()) SWIG_fail;
17150 }
17151 Py_INCREF(Py_None); resultobj = Py_None;
17152 return resultobj;
17153 fail:
17154 return NULL;
17155 }
17156
17157
17158 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
17159 PyObject *obj;
17160 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17161 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
17162 Py_INCREF(obj);
17163 return Py_BuildValue((char *)"");
17164 }
17165 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17166 PyObject *resultobj = NULL;
17167 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17168 wxMouseEvent *result;
17169 PyObject * obj0 = 0 ;
17170 char *kwnames[] = {
17171 (char *) "mouseType", NULL
17172 };
17173
17174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
17175 if (obj0) {
17176 {
17177 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
17178 if (SWIG_arg_fail(1)) SWIG_fail;
17179 }
17180 }
17181 {
17182 PyThreadState* __tstate = wxPyBeginAllowThreads();
17183 result = (wxMouseEvent *)new wxMouseEvent(arg1);
17184
17185 wxPyEndAllowThreads(__tstate);
17186 if (PyErr_Occurred()) SWIG_fail;
17187 }
17188 {
17189 resultobj = wxPyMake_wxObject(result, 1);
17190 }
17191 return resultobj;
17192 fail:
17193 return NULL;
17194 }
17195
17196
17197 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
17198 PyObject *resultobj = NULL;
17199 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17200 bool result;
17201 PyObject * obj0 = 0 ;
17202 char *kwnames[] = {
17203 (char *) "self", NULL
17204 };
17205
17206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
17207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17208 if (SWIG_arg_fail(1)) SWIG_fail;
17209 {
17210 PyThreadState* __tstate = wxPyBeginAllowThreads();
17211 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
17212
17213 wxPyEndAllowThreads(__tstate);
17214 if (PyErr_Occurred()) SWIG_fail;
17215 }
17216 {
17217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17218 }
17219 return resultobj;
17220 fail:
17221 return NULL;
17222 }
17223
17224
17225 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
17226 PyObject *resultobj = NULL;
17227 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17228 int arg2 = (int) wxMOUSE_BTN_ANY ;
17229 bool result;
17230 PyObject * obj0 = 0 ;
17231 PyObject * obj1 = 0 ;
17232 char *kwnames[] = {
17233 (char *) "self",(char *) "but", NULL
17234 };
17235
17236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
17237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17238 if (SWIG_arg_fail(1)) SWIG_fail;
17239 if (obj1) {
17240 {
17241 arg2 = static_cast<int >(SWIG_As_int(obj1));
17242 if (SWIG_arg_fail(2)) SWIG_fail;
17243 }
17244 }
17245 {
17246 PyThreadState* __tstate = wxPyBeginAllowThreads();
17247 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
17248
17249 wxPyEndAllowThreads(__tstate);
17250 if (PyErr_Occurred()) SWIG_fail;
17251 }
17252 {
17253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17254 }
17255 return resultobj;
17256 fail:
17257 return NULL;
17258 }
17259
17260
17261 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17262 PyObject *resultobj = NULL;
17263 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17264 int arg2 = (int) wxMOUSE_BTN_ANY ;
17265 bool result;
17266 PyObject * obj0 = 0 ;
17267 PyObject * obj1 = 0 ;
17268 char *kwnames[] = {
17269 (char *) "self",(char *) "but", NULL
17270 };
17271
17272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
17273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17274 if (SWIG_arg_fail(1)) SWIG_fail;
17275 if (obj1) {
17276 {
17277 arg2 = static_cast<int >(SWIG_As_int(obj1));
17278 if (SWIG_arg_fail(2)) SWIG_fail;
17279 }
17280 }
17281 {
17282 PyThreadState* __tstate = wxPyBeginAllowThreads();
17283 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
17284
17285 wxPyEndAllowThreads(__tstate);
17286 if (PyErr_Occurred()) SWIG_fail;
17287 }
17288 {
17289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17290 }
17291 return resultobj;
17292 fail:
17293 return NULL;
17294 }
17295
17296
17297 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
17298 PyObject *resultobj = NULL;
17299 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17300 int arg2 = (int) wxMOUSE_BTN_ANY ;
17301 bool result;
17302 PyObject * obj0 = 0 ;
17303 PyObject * obj1 = 0 ;
17304 char *kwnames[] = {
17305 (char *) "self",(char *) "but", NULL
17306 };
17307
17308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
17309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17310 if (SWIG_arg_fail(1)) SWIG_fail;
17311 if (obj1) {
17312 {
17313 arg2 = static_cast<int >(SWIG_As_int(obj1));
17314 if (SWIG_arg_fail(2)) SWIG_fail;
17315 }
17316 }
17317 {
17318 PyThreadState* __tstate = wxPyBeginAllowThreads();
17319 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
17320
17321 wxPyEndAllowThreads(__tstate);
17322 if (PyErr_Occurred()) SWIG_fail;
17323 }
17324 {
17325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17326 }
17327 return resultobj;
17328 fail:
17329 return NULL;
17330 }
17331
17332
17333 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
17334 PyObject *resultobj = NULL;
17335 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17336 int arg2 ;
17337 bool result;
17338 PyObject * obj0 = 0 ;
17339 PyObject * obj1 = 0 ;
17340 char *kwnames[] = {
17341 (char *) "self",(char *) "button", NULL
17342 };
17343
17344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
17345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17346 if (SWIG_arg_fail(1)) SWIG_fail;
17347 {
17348 arg2 = static_cast<int >(SWIG_As_int(obj1));
17349 if (SWIG_arg_fail(2)) SWIG_fail;
17350 }
17351 {
17352 PyThreadState* __tstate = wxPyBeginAllowThreads();
17353 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
17354
17355 wxPyEndAllowThreads(__tstate);
17356 if (PyErr_Occurred()) SWIG_fail;
17357 }
17358 {
17359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17360 }
17361 return resultobj;
17362 fail:
17363 return NULL;
17364 }
17365
17366
17367 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17368 PyObject *resultobj = NULL;
17369 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17370 int arg2 ;
17371 bool result;
17372 PyObject * obj0 = 0 ;
17373 PyObject * obj1 = 0 ;
17374 char *kwnames[] = {
17375 (char *) "self",(char *) "but", NULL
17376 };
17377
17378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
17379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17380 if (SWIG_arg_fail(1)) SWIG_fail;
17381 {
17382 arg2 = static_cast<int >(SWIG_As_int(obj1));
17383 if (SWIG_arg_fail(2)) SWIG_fail;
17384 }
17385 {
17386 PyThreadState* __tstate = wxPyBeginAllowThreads();
17387 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
17388
17389 wxPyEndAllowThreads(__tstate);
17390 if (PyErr_Occurred()) SWIG_fail;
17391 }
17392 {
17393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17394 }
17395 return resultobj;
17396 fail:
17397 return NULL;
17398 }
17399
17400
17401 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
17402 PyObject *resultobj = NULL;
17403 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17404 int result;
17405 PyObject * obj0 = 0 ;
17406 char *kwnames[] = {
17407 (char *) "self", NULL
17408 };
17409
17410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
17411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17412 if (SWIG_arg_fail(1)) SWIG_fail;
17413 {
17414 PyThreadState* __tstate = wxPyBeginAllowThreads();
17415 result = (int)((wxMouseEvent const *)arg1)->GetButton();
17416
17417 wxPyEndAllowThreads(__tstate);
17418 if (PyErr_Occurred()) SWIG_fail;
17419 }
17420 {
17421 resultobj = SWIG_From_int(static_cast<int >(result));
17422 }
17423 return resultobj;
17424 fail:
17425 return NULL;
17426 }
17427
17428
17429 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17430 PyObject *resultobj = NULL;
17431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17432 bool result;
17433 PyObject * obj0 = 0 ;
17434 char *kwnames[] = {
17435 (char *) "self", NULL
17436 };
17437
17438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
17439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17440 if (SWIG_arg_fail(1)) SWIG_fail;
17441 {
17442 PyThreadState* __tstate = wxPyBeginAllowThreads();
17443 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
17444
17445 wxPyEndAllowThreads(__tstate);
17446 if (PyErr_Occurred()) SWIG_fail;
17447 }
17448 {
17449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17450 }
17451 return resultobj;
17452 fail:
17453 return NULL;
17454 }
17455
17456
17457 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17458 PyObject *resultobj = NULL;
17459 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17460 bool result;
17461 PyObject * obj0 = 0 ;
17462 char *kwnames[] = {
17463 (char *) "self", NULL
17464 };
17465
17466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
17467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17468 if (SWIG_arg_fail(1)) SWIG_fail;
17469 {
17470 PyThreadState* __tstate = wxPyBeginAllowThreads();
17471 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
17472
17473 wxPyEndAllowThreads(__tstate);
17474 if (PyErr_Occurred()) SWIG_fail;
17475 }
17476 {
17477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17478 }
17479 return resultobj;
17480 fail:
17481 return NULL;
17482 }
17483
17484
17485 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17486 PyObject *resultobj = NULL;
17487 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17488 bool result;
17489 PyObject * obj0 = 0 ;
17490 char *kwnames[] = {
17491 (char *) "self", NULL
17492 };
17493
17494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
17495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17496 if (SWIG_arg_fail(1)) SWIG_fail;
17497 {
17498 PyThreadState* __tstate = wxPyBeginAllowThreads();
17499 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
17500
17501 wxPyEndAllowThreads(__tstate);
17502 if (PyErr_Occurred()) SWIG_fail;
17503 }
17504 {
17505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17506 }
17507 return resultobj;
17508 fail:
17509 return NULL;
17510 }
17511
17512
17513 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17514 PyObject *resultobj = NULL;
17515 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17516 bool result;
17517 PyObject * obj0 = 0 ;
17518 char *kwnames[] = {
17519 (char *) "self", NULL
17520 };
17521
17522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
17523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17524 if (SWIG_arg_fail(1)) SWIG_fail;
17525 {
17526 PyThreadState* __tstate = wxPyBeginAllowThreads();
17527 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
17528
17529 wxPyEndAllowThreads(__tstate);
17530 if (PyErr_Occurred()) SWIG_fail;
17531 }
17532 {
17533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17534 }
17535 return resultobj;
17536 fail:
17537 return NULL;
17538 }
17539
17540
17541 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17542 PyObject *resultobj = NULL;
17543 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17544 bool result;
17545 PyObject * obj0 = 0 ;
17546 char *kwnames[] = {
17547 (char *) "self", NULL
17548 };
17549
17550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
17551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17552 if (SWIG_arg_fail(1)) SWIG_fail;
17553 {
17554 PyThreadState* __tstate = wxPyBeginAllowThreads();
17555 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
17556
17557 wxPyEndAllowThreads(__tstate);
17558 if (PyErr_Occurred()) SWIG_fail;
17559 }
17560 {
17561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17562 }
17563 return resultobj;
17564 fail:
17565 return NULL;
17566 }
17567
17568
17569 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17570 PyObject *resultobj = NULL;
17571 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17572 bool result;
17573 PyObject * obj0 = 0 ;
17574 char *kwnames[] = {
17575 (char *) "self", NULL
17576 };
17577
17578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
17579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17580 if (SWIG_arg_fail(1)) SWIG_fail;
17581 {
17582 PyThreadState* __tstate = wxPyBeginAllowThreads();
17583 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
17584
17585 wxPyEndAllowThreads(__tstate);
17586 if (PyErr_Occurred()) SWIG_fail;
17587 }
17588 {
17589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17590 }
17591 return resultobj;
17592 fail:
17593 return NULL;
17594 }
17595
17596
17597 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
17598 PyObject *resultobj = NULL;
17599 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17600 bool result;
17601 PyObject * obj0 = 0 ;
17602 char *kwnames[] = {
17603 (char *) "self", NULL
17604 };
17605
17606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
17607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17608 if (SWIG_arg_fail(1)) SWIG_fail;
17609 {
17610 PyThreadState* __tstate = wxPyBeginAllowThreads();
17611 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
17612
17613 wxPyEndAllowThreads(__tstate);
17614 if (PyErr_Occurred()) SWIG_fail;
17615 }
17616 {
17617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17618 }
17619 return resultobj;
17620 fail:
17621 return NULL;
17622 }
17623
17624
17625 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
17626 PyObject *resultobj = NULL;
17627 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17628 bool result;
17629 PyObject * obj0 = 0 ;
17630 char *kwnames[] = {
17631 (char *) "self", NULL
17632 };
17633
17634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
17635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17636 if (SWIG_arg_fail(1)) SWIG_fail;
17637 {
17638 PyThreadState* __tstate = wxPyBeginAllowThreads();
17639 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
17640
17641 wxPyEndAllowThreads(__tstate);
17642 if (PyErr_Occurred()) SWIG_fail;
17643 }
17644 {
17645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17646 }
17647 return resultobj;
17648 fail:
17649 return NULL;
17650 }
17651
17652
17653 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
17654 PyObject *resultobj = NULL;
17655 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17656 bool result;
17657 PyObject * obj0 = 0 ;
17658 char *kwnames[] = {
17659 (char *) "self", NULL
17660 };
17661
17662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
17663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17664 if (SWIG_arg_fail(1)) SWIG_fail;
17665 {
17666 PyThreadState* __tstate = wxPyBeginAllowThreads();
17667 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
17668
17669 wxPyEndAllowThreads(__tstate);
17670 if (PyErr_Occurred()) SWIG_fail;
17671 }
17672 {
17673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17674 }
17675 return resultobj;
17676 fail:
17677 return NULL;
17678 }
17679
17680
17681 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
17682 PyObject *resultobj = NULL;
17683 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17684 bool result;
17685 PyObject * obj0 = 0 ;
17686 char *kwnames[] = {
17687 (char *) "self", NULL
17688 };
17689
17690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
17691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17692 if (SWIG_arg_fail(1)) SWIG_fail;
17693 {
17694 PyThreadState* __tstate = wxPyBeginAllowThreads();
17695 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
17696
17697 wxPyEndAllowThreads(__tstate);
17698 if (PyErr_Occurred()) SWIG_fail;
17699 }
17700 {
17701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17702 }
17703 return resultobj;
17704 fail:
17705 return NULL;
17706 }
17707
17708
17709 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
17710 PyObject *resultobj = NULL;
17711 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17712 bool result;
17713 PyObject * obj0 = 0 ;
17714 char *kwnames[] = {
17715 (char *) "self", NULL
17716 };
17717
17718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
17719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17720 if (SWIG_arg_fail(1)) SWIG_fail;
17721 {
17722 PyThreadState* __tstate = wxPyBeginAllowThreads();
17723 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
17724
17725 wxPyEndAllowThreads(__tstate);
17726 if (PyErr_Occurred()) SWIG_fail;
17727 }
17728 {
17729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17730 }
17731 return resultobj;
17732 fail:
17733 return NULL;
17734 }
17735
17736
17737 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17738 PyObject *resultobj = NULL;
17739 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17740 bool result;
17741 PyObject * obj0 = 0 ;
17742 char *kwnames[] = {
17743 (char *) "self", NULL
17744 };
17745
17746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
17747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17748 if (SWIG_arg_fail(1)) SWIG_fail;
17749 {
17750 PyThreadState* __tstate = wxPyBeginAllowThreads();
17751 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
17752
17753 wxPyEndAllowThreads(__tstate);
17754 if (PyErr_Occurred()) SWIG_fail;
17755 }
17756 {
17757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17758 }
17759 return resultobj;
17760 fail:
17761 return NULL;
17762 }
17763
17764
17765 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17766 PyObject *resultobj = NULL;
17767 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17768 bool result;
17769 PyObject * obj0 = 0 ;
17770 char *kwnames[] = {
17771 (char *) "self", NULL
17772 };
17773
17774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17776 if (SWIG_arg_fail(1)) SWIG_fail;
17777 {
17778 PyThreadState* __tstate = wxPyBeginAllowThreads();
17779 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17780
17781 wxPyEndAllowThreads(__tstate);
17782 if (PyErr_Occurred()) SWIG_fail;
17783 }
17784 {
17785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17786 }
17787 return resultobj;
17788 fail:
17789 return NULL;
17790 }
17791
17792
17793 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17794 PyObject *resultobj = NULL;
17795 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17796 bool result;
17797 PyObject * obj0 = 0 ;
17798 char *kwnames[] = {
17799 (char *) "self", NULL
17800 };
17801
17802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17804 if (SWIG_arg_fail(1)) SWIG_fail;
17805 {
17806 PyThreadState* __tstate = wxPyBeginAllowThreads();
17807 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17808
17809 wxPyEndAllowThreads(__tstate);
17810 if (PyErr_Occurred()) SWIG_fail;
17811 }
17812 {
17813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17814 }
17815 return resultobj;
17816 fail:
17817 return NULL;
17818 }
17819
17820
17821 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17822 PyObject *resultobj = NULL;
17823 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17824 bool result;
17825 PyObject * obj0 = 0 ;
17826 char *kwnames[] = {
17827 (char *) "self", NULL
17828 };
17829
17830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17832 if (SWIG_arg_fail(1)) SWIG_fail;
17833 {
17834 PyThreadState* __tstate = wxPyBeginAllowThreads();
17835 result = (bool)(arg1)->LeftIsDown();
17836
17837 wxPyEndAllowThreads(__tstate);
17838 if (PyErr_Occurred()) SWIG_fail;
17839 }
17840 {
17841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17842 }
17843 return resultobj;
17844 fail:
17845 return NULL;
17846 }
17847
17848
17849 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17850 PyObject *resultobj = NULL;
17851 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17852 bool result;
17853 PyObject * obj0 = 0 ;
17854 char *kwnames[] = {
17855 (char *) "self", NULL
17856 };
17857
17858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17860 if (SWIG_arg_fail(1)) SWIG_fail;
17861 {
17862 PyThreadState* __tstate = wxPyBeginAllowThreads();
17863 result = (bool)(arg1)->MiddleIsDown();
17864
17865 wxPyEndAllowThreads(__tstate);
17866 if (PyErr_Occurred()) SWIG_fail;
17867 }
17868 {
17869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17870 }
17871 return resultobj;
17872 fail:
17873 return NULL;
17874 }
17875
17876
17877 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17878 PyObject *resultobj = NULL;
17879 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17880 bool result;
17881 PyObject * obj0 = 0 ;
17882 char *kwnames[] = {
17883 (char *) "self", NULL
17884 };
17885
17886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17888 if (SWIG_arg_fail(1)) SWIG_fail;
17889 {
17890 PyThreadState* __tstate = wxPyBeginAllowThreads();
17891 result = (bool)(arg1)->RightIsDown();
17892
17893 wxPyEndAllowThreads(__tstate);
17894 if (PyErr_Occurred()) SWIG_fail;
17895 }
17896 {
17897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17898 }
17899 return resultobj;
17900 fail:
17901 return NULL;
17902 }
17903
17904
17905 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17906 PyObject *resultobj = NULL;
17907 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17908 bool result;
17909 PyObject * obj0 = 0 ;
17910 char *kwnames[] = {
17911 (char *) "self", NULL
17912 };
17913
17914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17916 if (SWIG_arg_fail(1)) SWIG_fail;
17917 {
17918 PyThreadState* __tstate = wxPyBeginAllowThreads();
17919 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17920
17921 wxPyEndAllowThreads(__tstate);
17922 if (PyErr_Occurred()) SWIG_fail;
17923 }
17924 {
17925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17926 }
17927 return resultobj;
17928 fail:
17929 return NULL;
17930 }
17931
17932
17933 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17934 PyObject *resultobj = NULL;
17935 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17936 bool result;
17937 PyObject * obj0 = 0 ;
17938 char *kwnames[] = {
17939 (char *) "self", NULL
17940 };
17941
17942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17944 if (SWIG_arg_fail(1)) SWIG_fail;
17945 {
17946 PyThreadState* __tstate = wxPyBeginAllowThreads();
17947 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17948
17949 wxPyEndAllowThreads(__tstate);
17950 if (PyErr_Occurred()) SWIG_fail;
17951 }
17952 {
17953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17954 }
17955 return resultobj;
17956 fail:
17957 return NULL;
17958 }
17959
17960
17961 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17962 PyObject *resultobj = NULL;
17963 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17964 bool result;
17965 PyObject * obj0 = 0 ;
17966 char *kwnames[] = {
17967 (char *) "self", NULL
17968 };
17969
17970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17972 if (SWIG_arg_fail(1)) SWIG_fail;
17973 {
17974 PyThreadState* __tstate = wxPyBeginAllowThreads();
17975 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17976
17977 wxPyEndAllowThreads(__tstate);
17978 if (PyErr_Occurred()) SWIG_fail;
17979 }
17980 {
17981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17982 }
17983 return resultobj;
17984 fail:
17985 return NULL;
17986 }
17987
17988
17989 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17990 PyObject *resultobj = NULL;
17991 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17992 bool result;
17993 PyObject * obj0 = 0 ;
17994 char *kwnames[] = {
17995 (char *) "self", NULL
17996 };
17997
17998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18000 if (SWIG_arg_fail(1)) SWIG_fail;
18001 {
18002 PyThreadState* __tstate = wxPyBeginAllowThreads();
18003 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
18004
18005 wxPyEndAllowThreads(__tstate);
18006 if (PyErr_Occurred()) SWIG_fail;
18007 }
18008 {
18009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18010 }
18011 return resultobj;
18012 fail:
18013 return NULL;
18014 }
18015
18016
18017 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18018 PyObject *resultobj = NULL;
18019 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18020 wxPoint result;
18021 PyObject * obj0 = 0 ;
18022 char *kwnames[] = {
18023 (char *) "self", NULL
18024 };
18025
18026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
18027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18028 if (SWIG_arg_fail(1)) SWIG_fail;
18029 {
18030 PyThreadState* __tstate = wxPyBeginAllowThreads();
18031 result = (arg1)->GetPosition();
18032
18033 wxPyEndAllowThreads(__tstate);
18034 if (PyErr_Occurred()) SWIG_fail;
18035 }
18036 {
18037 wxPoint * resultptr;
18038 resultptr = new wxPoint(static_cast<wxPoint & >(result));
18039 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18040 }
18041 return resultobj;
18042 fail:
18043 return NULL;
18044 }
18045
18046
18047 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18048 PyObject *resultobj = NULL;
18049 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18050 long *arg2 = (long *) 0 ;
18051 long *arg3 = (long *) 0 ;
18052 long temp2 ;
18053 int res2 = 0 ;
18054 long temp3 ;
18055 int res3 = 0 ;
18056 PyObject * obj0 = 0 ;
18057 char *kwnames[] = {
18058 (char *) "self", NULL
18059 };
18060
18061 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18062 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18065 if (SWIG_arg_fail(1)) SWIG_fail;
18066 {
18067 PyThreadState* __tstate = wxPyBeginAllowThreads();
18068 (arg1)->GetPosition(arg2,arg3);
18069
18070 wxPyEndAllowThreads(__tstate);
18071 if (PyErr_Occurred()) SWIG_fail;
18072 }
18073 Py_INCREF(Py_None); resultobj = Py_None;
18074 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18075 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18076 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18077 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18078 return resultobj;
18079 fail:
18080 return NULL;
18081 }
18082
18083
18084 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18085 PyObject *resultobj = NULL;
18086 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18087 wxDC *arg2 = 0 ;
18088 wxPoint result;
18089 PyObject * obj0 = 0 ;
18090 PyObject * obj1 = 0 ;
18091 char *kwnames[] = {
18092 (char *) "self",(char *) "dc", NULL
18093 };
18094
18095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
18096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18097 if (SWIG_arg_fail(1)) SWIG_fail;
18098 {
18099 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18100 if (SWIG_arg_fail(2)) SWIG_fail;
18101 if (arg2 == NULL) {
18102 SWIG_null_ref("wxDC");
18103 }
18104 if (SWIG_arg_fail(2)) SWIG_fail;
18105 }
18106 {
18107 PyThreadState* __tstate = wxPyBeginAllowThreads();
18108 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
18109
18110 wxPyEndAllowThreads(__tstate);
18111 if (PyErr_Occurred()) SWIG_fail;
18112 }
18113 {
18114 wxPoint * resultptr;
18115 resultptr = new wxPoint(static_cast<wxPoint & >(result));
18116 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18117 }
18118 return resultobj;
18119 fail:
18120 return NULL;
18121 }
18122
18123
18124 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18125 PyObject *resultobj = NULL;
18126 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18127 int result;
18128 PyObject * obj0 = 0 ;
18129 char *kwnames[] = {
18130 (char *) "self", NULL
18131 };
18132
18133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
18134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18135 if (SWIG_arg_fail(1)) SWIG_fail;
18136 {
18137 PyThreadState* __tstate = wxPyBeginAllowThreads();
18138 result = (int)((wxMouseEvent const *)arg1)->GetX();
18139
18140 wxPyEndAllowThreads(__tstate);
18141 if (PyErr_Occurred()) SWIG_fail;
18142 }
18143 {
18144 resultobj = SWIG_From_int(static_cast<int >(result));
18145 }
18146 return resultobj;
18147 fail:
18148 return NULL;
18149 }
18150
18151
18152 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18153 PyObject *resultobj = NULL;
18154 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18155 int result;
18156 PyObject * obj0 = 0 ;
18157 char *kwnames[] = {
18158 (char *) "self", NULL
18159 };
18160
18161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
18162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18163 if (SWIG_arg_fail(1)) SWIG_fail;
18164 {
18165 PyThreadState* __tstate = wxPyBeginAllowThreads();
18166 result = (int)((wxMouseEvent const *)arg1)->GetY();
18167
18168 wxPyEndAllowThreads(__tstate);
18169 if (PyErr_Occurred()) SWIG_fail;
18170 }
18171 {
18172 resultobj = SWIG_From_int(static_cast<int >(result));
18173 }
18174 return resultobj;
18175 fail:
18176 return NULL;
18177 }
18178
18179
18180 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
18181 PyObject *resultobj = NULL;
18182 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18183 int result;
18184 PyObject * obj0 = 0 ;
18185 char *kwnames[] = {
18186 (char *) "self", NULL
18187 };
18188
18189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
18190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18191 if (SWIG_arg_fail(1)) SWIG_fail;
18192 {
18193 PyThreadState* __tstate = wxPyBeginAllowThreads();
18194 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
18195
18196 wxPyEndAllowThreads(__tstate);
18197 if (PyErr_Occurred()) SWIG_fail;
18198 }
18199 {
18200 resultobj = SWIG_From_int(static_cast<int >(result));
18201 }
18202 return resultobj;
18203 fail:
18204 return NULL;
18205 }
18206
18207
18208 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
18209 PyObject *resultobj = NULL;
18210 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18211 int result;
18212 PyObject * obj0 = 0 ;
18213 char *kwnames[] = {
18214 (char *) "self", NULL
18215 };
18216
18217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
18218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18219 if (SWIG_arg_fail(1)) SWIG_fail;
18220 {
18221 PyThreadState* __tstate = wxPyBeginAllowThreads();
18222 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
18223
18224 wxPyEndAllowThreads(__tstate);
18225 if (PyErr_Occurred()) SWIG_fail;
18226 }
18227 {
18228 resultobj = SWIG_From_int(static_cast<int >(result));
18229 }
18230 return resultobj;
18231 fail:
18232 return NULL;
18233 }
18234
18235
18236 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
18237 PyObject *resultobj = NULL;
18238 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18239 int result;
18240 PyObject * obj0 = 0 ;
18241 char *kwnames[] = {
18242 (char *) "self", NULL
18243 };
18244
18245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
18246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18247 if (SWIG_arg_fail(1)) SWIG_fail;
18248 {
18249 PyThreadState* __tstate = wxPyBeginAllowThreads();
18250 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
18251
18252 wxPyEndAllowThreads(__tstate);
18253 if (PyErr_Occurred()) SWIG_fail;
18254 }
18255 {
18256 resultobj = SWIG_From_int(static_cast<int >(result));
18257 }
18258 return resultobj;
18259 fail:
18260 return NULL;
18261 }
18262
18263
18264 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
18265 PyObject *resultobj = NULL;
18266 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18267 bool result;
18268 PyObject * obj0 = 0 ;
18269 char *kwnames[] = {
18270 (char *) "self", NULL
18271 };
18272
18273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
18274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18275 if (SWIG_arg_fail(1)) SWIG_fail;
18276 {
18277 PyThreadState* __tstate = wxPyBeginAllowThreads();
18278 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
18279
18280 wxPyEndAllowThreads(__tstate);
18281 if (PyErr_Occurred()) SWIG_fail;
18282 }
18283 {
18284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18285 }
18286 return resultobj;
18287 fail:
18288 return NULL;
18289 }
18290
18291
18292 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18293 PyObject *resultobj = NULL;
18294 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18295 int arg2 ;
18296 PyObject * obj0 = 0 ;
18297 PyObject * obj1 = 0 ;
18298 char *kwnames[] = {
18299 (char *) "self",(char *) "m_x", NULL
18300 };
18301
18302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18304 if (SWIG_arg_fail(1)) SWIG_fail;
18305 {
18306 arg2 = static_cast<int >(SWIG_As_int(obj1));
18307 if (SWIG_arg_fail(2)) SWIG_fail;
18308 }
18309 if (arg1) (arg1)->m_x = arg2;
18310
18311 Py_INCREF(Py_None); resultobj = Py_None;
18312 return resultobj;
18313 fail:
18314 return NULL;
18315 }
18316
18317
18318 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18319 PyObject *resultobj = NULL;
18320 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18321 int result;
18322 PyObject * obj0 = 0 ;
18323 char *kwnames[] = {
18324 (char *) "self", NULL
18325 };
18326
18327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
18328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18329 if (SWIG_arg_fail(1)) SWIG_fail;
18330 result = (int) ((arg1)->m_x);
18331
18332 {
18333 resultobj = SWIG_From_int(static_cast<int >(result));
18334 }
18335 return resultobj;
18336 fail:
18337 return NULL;
18338 }
18339
18340
18341 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18342 PyObject *resultobj = NULL;
18343 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18344 int arg2 ;
18345 PyObject * obj0 = 0 ;
18346 PyObject * obj1 = 0 ;
18347 char *kwnames[] = {
18348 (char *) "self",(char *) "m_y", NULL
18349 };
18350
18351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18353 if (SWIG_arg_fail(1)) SWIG_fail;
18354 {
18355 arg2 = static_cast<int >(SWIG_As_int(obj1));
18356 if (SWIG_arg_fail(2)) SWIG_fail;
18357 }
18358 if (arg1) (arg1)->m_y = arg2;
18359
18360 Py_INCREF(Py_None); resultobj = Py_None;
18361 return resultobj;
18362 fail:
18363 return NULL;
18364 }
18365
18366
18367 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18368 PyObject *resultobj = NULL;
18369 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18370 int result;
18371 PyObject * obj0 = 0 ;
18372 char *kwnames[] = {
18373 (char *) "self", NULL
18374 };
18375
18376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
18377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18378 if (SWIG_arg_fail(1)) SWIG_fail;
18379 result = (int) ((arg1)->m_y);
18380
18381 {
18382 resultobj = SWIG_From_int(static_cast<int >(result));
18383 }
18384 return resultobj;
18385 fail:
18386 return NULL;
18387 }
18388
18389
18390 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18391 PyObject *resultobj = NULL;
18392 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18393 bool arg2 ;
18394 PyObject * obj0 = 0 ;
18395 PyObject * obj1 = 0 ;
18396 char *kwnames[] = {
18397 (char *) "self",(char *) "m_leftDown", NULL
18398 };
18399
18400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
18401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18402 if (SWIG_arg_fail(1)) SWIG_fail;
18403 {
18404 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18405 if (SWIG_arg_fail(2)) SWIG_fail;
18406 }
18407 if (arg1) (arg1)->m_leftDown = arg2;
18408
18409 Py_INCREF(Py_None); resultobj = Py_None;
18410 return resultobj;
18411 fail:
18412 return NULL;
18413 }
18414
18415
18416 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18417 PyObject *resultobj = NULL;
18418 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18419 bool result;
18420 PyObject * obj0 = 0 ;
18421 char *kwnames[] = {
18422 (char *) "self", NULL
18423 };
18424
18425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
18426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18427 if (SWIG_arg_fail(1)) SWIG_fail;
18428 result = (bool) ((arg1)->m_leftDown);
18429
18430 {
18431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18432 }
18433 return resultobj;
18434 fail:
18435 return NULL;
18436 }
18437
18438
18439 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18440 PyObject *resultobj = NULL;
18441 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18442 bool arg2 ;
18443 PyObject * obj0 = 0 ;
18444 PyObject * obj1 = 0 ;
18445 char *kwnames[] = {
18446 (char *) "self",(char *) "m_middleDown", NULL
18447 };
18448
18449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
18450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18451 if (SWIG_arg_fail(1)) SWIG_fail;
18452 {
18453 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18454 if (SWIG_arg_fail(2)) SWIG_fail;
18455 }
18456 if (arg1) (arg1)->m_middleDown = arg2;
18457
18458 Py_INCREF(Py_None); resultobj = Py_None;
18459 return resultobj;
18460 fail:
18461 return NULL;
18462 }
18463
18464
18465 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18466 PyObject *resultobj = NULL;
18467 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18468 bool result;
18469 PyObject * obj0 = 0 ;
18470 char *kwnames[] = {
18471 (char *) "self", NULL
18472 };
18473
18474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
18475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18476 if (SWIG_arg_fail(1)) SWIG_fail;
18477 result = (bool) ((arg1)->m_middleDown);
18478
18479 {
18480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18481 }
18482 return resultobj;
18483 fail:
18484 return NULL;
18485 }
18486
18487
18488 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18489 PyObject *resultobj = NULL;
18490 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18491 bool arg2 ;
18492 PyObject * obj0 = 0 ;
18493 PyObject * obj1 = 0 ;
18494 char *kwnames[] = {
18495 (char *) "self",(char *) "m_rightDown", NULL
18496 };
18497
18498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
18499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18500 if (SWIG_arg_fail(1)) SWIG_fail;
18501 {
18502 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18503 if (SWIG_arg_fail(2)) SWIG_fail;
18504 }
18505 if (arg1) (arg1)->m_rightDown = arg2;
18506
18507 Py_INCREF(Py_None); resultobj = Py_None;
18508 return resultobj;
18509 fail:
18510 return NULL;
18511 }
18512
18513
18514 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18515 PyObject *resultobj = NULL;
18516 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18517 bool result;
18518 PyObject * obj0 = 0 ;
18519 char *kwnames[] = {
18520 (char *) "self", NULL
18521 };
18522
18523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
18524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18525 if (SWIG_arg_fail(1)) SWIG_fail;
18526 result = (bool) ((arg1)->m_rightDown);
18527
18528 {
18529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18530 }
18531 return resultobj;
18532 fail:
18533 return NULL;
18534 }
18535
18536
18537 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18538 PyObject *resultobj = NULL;
18539 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18540 bool arg2 ;
18541 PyObject * obj0 = 0 ;
18542 PyObject * obj1 = 0 ;
18543 char *kwnames[] = {
18544 (char *) "self",(char *) "m_controlDown", NULL
18545 };
18546
18547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18549 if (SWIG_arg_fail(1)) SWIG_fail;
18550 {
18551 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18552 if (SWIG_arg_fail(2)) SWIG_fail;
18553 }
18554 if (arg1) (arg1)->m_controlDown = arg2;
18555
18556 Py_INCREF(Py_None); resultobj = Py_None;
18557 return resultobj;
18558 fail:
18559 return NULL;
18560 }
18561
18562
18563 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18564 PyObject *resultobj = NULL;
18565 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18566 bool result;
18567 PyObject * obj0 = 0 ;
18568 char *kwnames[] = {
18569 (char *) "self", NULL
18570 };
18571
18572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18574 if (SWIG_arg_fail(1)) SWIG_fail;
18575 result = (bool) ((arg1)->m_controlDown);
18576
18577 {
18578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18579 }
18580 return resultobj;
18581 fail:
18582 return NULL;
18583 }
18584
18585
18586 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18587 PyObject *resultobj = NULL;
18588 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18589 bool arg2 ;
18590 PyObject * obj0 = 0 ;
18591 PyObject * obj1 = 0 ;
18592 char *kwnames[] = {
18593 (char *) "self",(char *) "m_shiftDown", NULL
18594 };
18595
18596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18598 if (SWIG_arg_fail(1)) SWIG_fail;
18599 {
18600 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18601 if (SWIG_arg_fail(2)) SWIG_fail;
18602 }
18603 if (arg1) (arg1)->m_shiftDown = arg2;
18604
18605 Py_INCREF(Py_None); resultobj = Py_None;
18606 return resultobj;
18607 fail:
18608 return NULL;
18609 }
18610
18611
18612 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18613 PyObject *resultobj = NULL;
18614 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18615 bool result;
18616 PyObject * obj0 = 0 ;
18617 char *kwnames[] = {
18618 (char *) "self", NULL
18619 };
18620
18621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18623 if (SWIG_arg_fail(1)) SWIG_fail;
18624 result = (bool) ((arg1)->m_shiftDown);
18625
18626 {
18627 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18628 }
18629 return resultobj;
18630 fail:
18631 return NULL;
18632 }
18633
18634
18635 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18636 PyObject *resultobj = NULL;
18637 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18638 bool arg2 ;
18639 PyObject * obj0 = 0 ;
18640 PyObject * obj1 = 0 ;
18641 char *kwnames[] = {
18642 (char *) "self",(char *) "m_altDown", NULL
18643 };
18644
18645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18647 if (SWIG_arg_fail(1)) SWIG_fail;
18648 {
18649 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18650 if (SWIG_arg_fail(2)) SWIG_fail;
18651 }
18652 if (arg1) (arg1)->m_altDown = arg2;
18653
18654 Py_INCREF(Py_None); resultobj = Py_None;
18655 return resultobj;
18656 fail:
18657 return NULL;
18658 }
18659
18660
18661 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18662 PyObject *resultobj = NULL;
18663 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18664 bool result;
18665 PyObject * obj0 = 0 ;
18666 char *kwnames[] = {
18667 (char *) "self", NULL
18668 };
18669
18670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18672 if (SWIG_arg_fail(1)) SWIG_fail;
18673 result = (bool) ((arg1)->m_altDown);
18674
18675 {
18676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18677 }
18678 return resultobj;
18679 fail:
18680 return NULL;
18681 }
18682
18683
18684 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18685 PyObject *resultobj = NULL;
18686 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18687 bool arg2 ;
18688 PyObject * obj0 = 0 ;
18689 PyObject * obj1 = 0 ;
18690 char *kwnames[] = {
18691 (char *) "self",(char *) "m_metaDown", NULL
18692 };
18693
18694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18696 if (SWIG_arg_fail(1)) SWIG_fail;
18697 {
18698 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18699 if (SWIG_arg_fail(2)) SWIG_fail;
18700 }
18701 if (arg1) (arg1)->m_metaDown = arg2;
18702
18703 Py_INCREF(Py_None); resultobj = Py_None;
18704 return resultobj;
18705 fail:
18706 return NULL;
18707 }
18708
18709
18710 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18711 PyObject *resultobj = NULL;
18712 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18713 bool result;
18714 PyObject * obj0 = 0 ;
18715 char *kwnames[] = {
18716 (char *) "self", NULL
18717 };
18718
18719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18721 if (SWIG_arg_fail(1)) SWIG_fail;
18722 result = (bool) ((arg1)->m_metaDown);
18723
18724 {
18725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18726 }
18727 return resultobj;
18728 fail:
18729 return NULL;
18730 }
18731
18732
18733 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
18734 PyObject *resultobj = NULL;
18735 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18736 int arg2 ;
18737 PyObject * obj0 = 0 ;
18738 PyObject * obj1 = 0 ;
18739 char *kwnames[] = {
18740 (char *) "self",(char *) "m_wheelRotation", NULL
18741 };
18742
18743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
18744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18745 if (SWIG_arg_fail(1)) SWIG_fail;
18746 {
18747 arg2 = static_cast<int >(SWIG_As_int(obj1));
18748 if (SWIG_arg_fail(2)) SWIG_fail;
18749 }
18750 if (arg1) (arg1)->m_wheelRotation = arg2;
18751
18752 Py_INCREF(Py_None); resultobj = Py_None;
18753 return resultobj;
18754 fail:
18755 return NULL;
18756 }
18757
18758
18759 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
18760 PyObject *resultobj = NULL;
18761 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18762 int result;
18763 PyObject * obj0 = 0 ;
18764 char *kwnames[] = {
18765 (char *) "self", NULL
18766 };
18767
18768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18770 if (SWIG_arg_fail(1)) SWIG_fail;
18771 result = (int) ((arg1)->m_wheelRotation);
18772
18773 {
18774 resultobj = SWIG_From_int(static_cast<int >(result));
18775 }
18776 return resultobj;
18777 fail:
18778 return NULL;
18779 }
18780
18781
18782 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18783 PyObject *resultobj = NULL;
18784 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18785 int arg2 ;
18786 PyObject * obj0 = 0 ;
18787 PyObject * obj1 = 0 ;
18788 char *kwnames[] = {
18789 (char *) "self",(char *) "m_wheelDelta", NULL
18790 };
18791
18792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18794 if (SWIG_arg_fail(1)) SWIG_fail;
18795 {
18796 arg2 = static_cast<int >(SWIG_As_int(obj1));
18797 if (SWIG_arg_fail(2)) SWIG_fail;
18798 }
18799 if (arg1) (arg1)->m_wheelDelta = arg2;
18800
18801 Py_INCREF(Py_None); resultobj = Py_None;
18802 return resultobj;
18803 fail:
18804 return NULL;
18805 }
18806
18807
18808 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18809 PyObject *resultobj = NULL;
18810 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18811 int result;
18812 PyObject * obj0 = 0 ;
18813 char *kwnames[] = {
18814 (char *) "self", NULL
18815 };
18816
18817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18819 if (SWIG_arg_fail(1)) SWIG_fail;
18820 result = (int) ((arg1)->m_wheelDelta);
18821
18822 {
18823 resultobj = SWIG_From_int(static_cast<int >(result));
18824 }
18825 return resultobj;
18826 fail:
18827 return NULL;
18828 }
18829
18830
18831 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18832 PyObject *resultobj = NULL;
18833 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18834 int arg2 ;
18835 PyObject * obj0 = 0 ;
18836 PyObject * obj1 = 0 ;
18837 char *kwnames[] = {
18838 (char *) "self",(char *) "m_linesPerAction", NULL
18839 };
18840
18841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18843 if (SWIG_arg_fail(1)) SWIG_fail;
18844 {
18845 arg2 = static_cast<int >(SWIG_As_int(obj1));
18846 if (SWIG_arg_fail(2)) SWIG_fail;
18847 }
18848 if (arg1) (arg1)->m_linesPerAction = arg2;
18849
18850 Py_INCREF(Py_None); resultobj = Py_None;
18851 return resultobj;
18852 fail:
18853 return NULL;
18854 }
18855
18856
18857 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18858 PyObject *resultobj = NULL;
18859 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18860 int result;
18861 PyObject * obj0 = 0 ;
18862 char *kwnames[] = {
18863 (char *) "self", NULL
18864 };
18865
18866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18868 if (SWIG_arg_fail(1)) SWIG_fail;
18869 result = (int) ((arg1)->m_linesPerAction);
18870
18871 {
18872 resultobj = SWIG_From_int(static_cast<int >(result));
18873 }
18874 return resultobj;
18875 fail:
18876 return NULL;
18877 }
18878
18879
18880 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18881 PyObject *obj;
18882 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18883 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18884 Py_INCREF(obj);
18885 return Py_BuildValue((char *)"");
18886 }
18887 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18888 PyObject *resultobj = NULL;
18889 int arg1 = (int) 0 ;
18890 int arg2 = (int) 0 ;
18891 wxSetCursorEvent *result;
18892 PyObject * obj0 = 0 ;
18893 PyObject * obj1 = 0 ;
18894 char *kwnames[] = {
18895 (char *) "x",(char *) "y", NULL
18896 };
18897
18898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18899 if (obj0) {
18900 {
18901 arg1 = static_cast<int >(SWIG_As_int(obj0));
18902 if (SWIG_arg_fail(1)) SWIG_fail;
18903 }
18904 }
18905 if (obj1) {
18906 {
18907 arg2 = static_cast<int >(SWIG_As_int(obj1));
18908 if (SWIG_arg_fail(2)) SWIG_fail;
18909 }
18910 }
18911 {
18912 PyThreadState* __tstate = wxPyBeginAllowThreads();
18913 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18914
18915 wxPyEndAllowThreads(__tstate);
18916 if (PyErr_Occurred()) SWIG_fail;
18917 }
18918 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18919 return resultobj;
18920 fail:
18921 return NULL;
18922 }
18923
18924
18925 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18926 PyObject *resultobj = NULL;
18927 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18928 int result;
18929 PyObject * obj0 = 0 ;
18930 char *kwnames[] = {
18931 (char *) "self", NULL
18932 };
18933
18934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18936 if (SWIG_arg_fail(1)) SWIG_fail;
18937 {
18938 PyThreadState* __tstate = wxPyBeginAllowThreads();
18939 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18940
18941 wxPyEndAllowThreads(__tstate);
18942 if (PyErr_Occurred()) SWIG_fail;
18943 }
18944 {
18945 resultobj = SWIG_From_int(static_cast<int >(result));
18946 }
18947 return resultobj;
18948 fail:
18949 return NULL;
18950 }
18951
18952
18953 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18954 PyObject *resultobj = NULL;
18955 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18956 int result;
18957 PyObject * obj0 = 0 ;
18958 char *kwnames[] = {
18959 (char *) "self", NULL
18960 };
18961
18962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18964 if (SWIG_arg_fail(1)) SWIG_fail;
18965 {
18966 PyThreadState* __tstate = wxPyBeginAllowThreads();
18967 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18968
18969 wxPyEndAllowThreads(__tstate);
18970 if (PyErr_Occurred()) SWIG_fail;
18971 }
18972 {
18973 resultobj = SWIG_From_int(static_cast<int >(result));
18974 }
18975 return resultobj;
18976 fail:
18977 return NULL;
18978 }
18979
18980
18981 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18982 PyObject *resultobj = NULL;
18983 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18984 wxCursor *arg2 = 0 ;
18985 PyObject * obj0 = 0 ;
18986 PyObject * obj1 = 0 ;
18987 char *kwnames[] = {
18988 (char *) "self",(char *) "cursor", NULL
18989 };
18990
18991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18993 if (SWIG_arg_fail(1)) SWIG_fail;
18994 {
18995 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18996 if (SWIG_arg_fail(2)) SWIG_fail;
18997 if (arg2 == NULL) {
18998 SWIG_null_ref("wxCursor");
18999 }
19000 if (SWIG_arg_fail(2)) SWIG_fail;
19001 }
19002 {
19003 PyThreadState* __tstate = wxPyBeginAllowThreads();
19004 (arg1)->SetCursor((wxCursor const &)*arg2);
19005
19006 wxPyEndAllowThreads(__tstate);
19007 if (PyErr_Occurred()) SWIG_fail;
19008 }
19009 Py_INCREF(Py_None); resultobj = Py_None;
19010 return resultobj;
19011 fail:
19012 return NULL;
19013 }
19014
19015
19016 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19017 PyObject *resultobj = NULL;
19018 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19019 wxCursor *result;
19020 PyObject * obj0 = 0 ;
19021 char *kwnames[] = {
19022 (char *) "self", NULL
19023 };
19024
19025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
19026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19027 if (SWIG_arg_fail(1)) SWIG_fail;
19028 {
19029 PyThreadState* __tstate = wxPyBeginAllowThreads();
19030 {
19031 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
19032 result = (wxCursor *) &_result_ref;
19033 }
19034
19035 wxPyEndAllowThreads(__tstate);
19036 if (PyErr_Occurred()) SWIG_fail;
19037 }
19038 {
19039 wxCursor* resultptr = new wxCursor(*result);
19040 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
19041 }
19042 return resultobj;
19043 fail:
19044 return NULL;
19045 }
19046
19047
19048 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19049 PyObject *resultobj = NULL;
19050 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19051 bool result;
19052 PyObject * obj0 = 0 ;
19053 char *kwnames[] = {
19054 (char *) "self", NULL
19055 };
19056
19057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
19058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19059 if (SWIG_arg_fail(1)) SWIG_fail;
19060 {
19061 PyThreadState* __tstate = wxPyBeginAllowThreads();
19062 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
19063
19064 wxPyEndAllowThreads(__tstate);
19065 if (PyErr_Occurred()) SWIG_fail;
19066 }
19067 {
19068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19069 }
19070 return resultobj;
19071 fail:
19072 return NULL;
19073 }
19074
19075
19076 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
19077 PyObject *obj;
19078 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19079 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
19080 Py_INCREF(obj);
19081 return Py_BuildValue((char *)"");
19082 }
19083 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19084 PyObject *resultobj = NULL;
19085 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19086 wxKeyEvent *result;
19087 PyObject * obj0 = 0 ;
19088 char *kwnames[] = {
19089 (char *) "eventType", NULL
19090 };
19091
19092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
19093 if (obj0) {
19094 {
19095 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
19096 if (SWIG_arg_fail(1)) SWIG_fail;
19097 }
19098 }
19099 {
19100 PyThreadState* __tstate = wxPyBeginAllowThreads();
19101 result = (wxKeyEvent *)new wxKeyEvent(arg1);
19102
19103 wxPyEndAllowThreads(__tstate);
19104 if (PyErr_Occurred()) SWIG_fail;
19105 }
19106 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
19107 return resultobj;
19108 fail:
19109 return NULL;
19110 }
19111
19112
19113 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
19114 PyObject *resultobj = NULL;
19115 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19116 bool result;
19117 PyObject * obj0 = 0 ;
19118 char *kwnames[] = {
19119 (char *) "self", NULL
19120 };
19121
19122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
19123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19124 if (SWIG_arg_fail(1)) SWIG_fail;
19125 {
19126 PyThreadState* __tstate = wxPyBeginAllowThreads();
19127 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
19128
19129 wxPyEndAllowThreads(__tstate);
19130 if (PyErr_Occurred()) SWIG_fail;
19131 }
19132 {
19133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19134 }
19135 return resultobj;
19136 fail:
19137 return NULL;
19138 }
19139
19140
19141 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
19142 PyObject *resultobj = NULL;
19143 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19144 bool result;
19145 PyObject * obj0 = 0 ;
19146 char *kwnames[] = {
19147 (char *) "self", NULL
19148 };
19149
19150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
19151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19152 if (SWIG_arg_fail(1)) SWIG_fail;
19153 {
19154 PyThreadState* __tstate = wxPyBeginAllowThreads();
19155 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
19156
19157 wxPyEndAllowThreads(__tstate);
19158 if (PyErr_Occurred()) SWIG_fail;
19159 }
19160 {
19161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19162 }
19163 return resultobj;
19164 fail:
19165 return NULL;
19166 }
19167
19168
19169 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
19170 PyObject *resultobj = NULL;
19171 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19172 bool result;
19173 PyObject * obj0 = 0 ;
19174 char *kwnames[] = {
19175 (char *) "self", NULL
19176 };
19177
19178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
19179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19180 if (SWIG_arg_fail(1)) SWIG_fail;
19181 {
19182 PyThreadState* __tstate = wxPyBeginAllowThreads();
19183 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
19184
19185 wxPyEndAllowThreads(__tstate);
19186 if (PyErr_Occurred()) SWIG_fail;
19187 }
19188 {
19189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19190 }
19191 return resultobj;
19192 fail:
19193 return NULL;
19194 }
19195
19196
19197 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
19198 PyObject *resultobj = NULL;
19199 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19200 bool result;
19201 PyObject * obj0 = 0 ;
19202 char *kwnames[] = {
19203 (char *) "self", NULL
19204 };
19205
19206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
19207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19208 if (SWIG_arg_fail(1)) SWIG_fail;
19209 {
19210 PyThreadState* __tstate = wxPyBeginAllowThreads();
19211 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
19212
19213 wxPyEndAllowThreads(__tstate);
19214 if (PyErr_Occurred()) SWIG_fail;
19215 }
19216 {
19217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19218 }
19219 return resultobj;
19220 fail:
19221 return NULL;
19222 }
19223
19224
19225 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
19226 PyObject *resultobj = NULL;
19227 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19228 bool result;
19229 PyObject * obj0 = 0 ;
19230 char *kwnames[] = {
19231 (char *) "self", NULL
19232 };
19233
19234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
19235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19236 if (SWIG_arg_fail(1)) SWIG_fail;
19237 {
19238 PyThreadState* __tstate = wxPyBeginAllowThreads();
19239 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
19240
19241 wxPyEndAllowThreads(__tstate);
19242 if (PyErr_Occurred()) SWIG_fail;
19243 }
19244 {
19245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19246 }
19247 return resultobj;
19248 fail:
19249 return NULL;
19250 }
19251
19252
19253 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
19254 PyObject *resultobj = NULL;
19255 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19256 bool result;
19257 PyObject * obj0 = 0 ;
19258 char *kwnames[] = {
19259 (char *) "self", NULL
19260 };
19261
19262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
19263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19264 if (SWIG_arg_fail(1)) SWIG_fail;
19265 {
19266 PyThreadState* __tstate = wxPyBeginAllowThreads();
19267 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
19268
19269 wxPyEndAllowThreads(__tstate);
19270 if (PyErr_Occurred()) SWIG_fail;
19271 }
19272 {
19273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19274 }
19275 return resultobj;
19276 fail:
19277 return NULL;
19278 }
19279
19280
19281 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19282 PyObject *resultobj = NULL;
19283 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19284 int result;
19285 PyObject * obj0 = 0 ;
19286 char *kwnames[] = {
19287 (char *) "self", NULL
19288 };
19289
19290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
19291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19292 if (SWIG_arg_fail(1)) SWIG_fail;
19293 {
19294 PyThreadState* __tstate = wxPyBeginAllowThreads();
19295 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
19296
19297 wxPyEndAllowThreads(__tstate);
19298 if (PyErr_Occurred()) SWIG_fail;
19299 }
19300 {
19301 resultobj = SWIG_From_int(static_cast<int >(result));
19302 }
19303 return resultobj;
19304 fail:
19305 return NULL;
19306 }
19307
19308
19309 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
19310 PyObject *resultobj = NULL;
19311 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19312 int result;
19313 PyObject * obj0 = 0 ;
19314 char *kwnames[] = {
19315 (char *) "self", NULL
19316 };
19317
19318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
19319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19320 if (SWIG_arg_fail(1)) SWIG_fail;
19321 {
19322 PyThreadState* __tstate = wxPyBeginAllowThreads();
19323 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
19324
19325 wxPyEndAllowThreads(__tstate);
19326 if (PyErr_Occurred()) SWIG_fail;
19327 }
19328 {
19329 resultobj = SWIG_From_int(static_cast<int >(result));
19330 }
19331 return resultobj;
19332 fail:
19333 return NULL;
19334 }
19335
19336
19337 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19338 PyObject *resultobj = NULL;
19339 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19340 unsigned int result;
19341 PyObject * obj0 = 0 ;
19342 char *kwnames[] = {
19343 (char *) "self", NULL
19344 };
19345
19346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
19347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19348 if (SWIG_arg_fail(1)) SWIG_fail;
19349 {
19350 PyThreadState* __tstate = wxPyBeginAllowThreads();
19351 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
19352
19353 wxPyEndAllowThreads(__tstate);
19354 if (PyErr_Occurred()) SWIG_fail;
19355 }
19356 {
19357 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19358 }
19359 return resultobj;
19360 fail:
19361 return NULL;
19362 }
19363
19364
19365 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
19366 PyObject *resultobj = NULL;
19367 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19368 unsigned int result;
19369 PyObject * obj0 = 0 ;
19370 char *kwnames[] = {
19371 (char *) "self", NULL
19372 };
19373
19374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
19375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19376 if (SWIG_arg_fail(1)) SWIG_fail;
19377 {
19378 PyThreadState* __tstate = wxPyBeginAllowThreads();
19379 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
19380
19381 wxPyEndAllowThreads(__tstate);
19382 if (PyErr_Occurred()) SWIG_fail;
19383 }
19384 {
19385 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19386 }
19387 return resultobj;
19388 fail:
19389 return NULL;
19390 }
19391
19392
19393 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19394 PyObject *resultobj = NULL;
19395 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19396 wxPoint result;
19397 PyObject * obj0 = 0 ;
19398 char *kwnames[] = {
19399 (char *) "self", NULL
19400 };
19401
19402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
19403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19404 if (SWIG_arg_fail(1)) SWIG_fail;
19405 {
19406 PyThreadState* __tstate = wxPyBeginAllowThreads();
19407 result = (arg1)->GetPosition();
19408
19409 wxPyEndAllowThreads(__tstate);
19410 if (PyErr_Occurred()) SWIG_fail;
19411 }
19412 {
19413 wxPoint * resultptr;
19414 resultptr = new wxPoint(static_cast<wxPoint & >(result));
19415 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19416 }
19417 return resultobj;
19418 fail:
19419 return NULL;
19420 }
19421
19422
19423 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
19424 PyObject *resultobj = NULL;
19425 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19426 long *arg2 = (long *) 0 ;
19427 long *arg3 = (long *) 0 ;
19428 long temp2 ;
19429 int res2 = 0 ;
19430 long temp3 ;
19431 int res3 = 0 ;
19432 PyObject * obj0 = 0 ;
19433 char *kwnames[] = {
19434 (char *) "self", NULL
19435 };
19436
19437 arg2 = &temp2; res2 = SWIG_NEWOBJ;
19438 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
19440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19441 if (SWIG_arg_fail(1)) SWIG_fail;
19442 {
19443 PyThreadState* __tstate = wxPyBeginAllowThreads();
19444 (arg1)->GetPosition(arg2,arg3);
19445
19446 wxPyEndAllowThreads(__tstate);
19447 if (PyErr_Occurred()) SWIG_fail;
19448 }
19449 Py_INCREF(Py_None); resultobj = Py_None;
19450 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19451 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
19452 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19453 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
19454 return resultobj;
19455 fail:
19456 return NULL;
19457 }
19458
19459
19460 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
19461 PyObject *resultobj = NULL;
19462 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19463 int result;
19464 PyObject * obj0 = 0 ;
19465 char *kwnames[] = {
19466 (char *) "self", NULL
19467 };
19468
19469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
19470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19471 if (SWIG_arg_fail(1)) SWIG_fail;
19472 {
19473 PyThreadState* __tstate = wxPyBeginAllowThreads();
19474 result = (int)((wxKeyEvent const *)arg1)->GetX();
19475
19476 wxPyEndAllowThreads(__tstate);
19477 if (PyErr_Occurred()) SWIG_fail;
19478 }
19479 {
19480 resultobj = SWIG_From_int(static_cast<int >(result));
19481 }
19482 return resultobj;
19483 fail:
19484 return NULL;
19485 }
19486
19487
19488 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
19489 PyObject *resultobj = NULL;
19490 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19491 int result;
19492 PyObject * obj0 = 0 ;
19493 char *kwnames[] = {
19494 (char *) "self", NULL
19495 };
19496
19497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
19498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19499 if (SWIG_arg_fail(1)) SWIG_fail;
19500 {
19501 PyThreadState* __tstate = wxPyBeginAllowThreads();
19502 result = (int)((wxKeyEvent const *)arg1)->GetY();
19503
19504 wxPyEndAllowThreads(__tstate);
19505 if (PyErr_Occurred()) SWIG_fail;
19506 }
19507 {
19508 resultobj = SWIG_From_int(static_cast<int >(result));
19509 }
19510 return resultobj;
19511 fail:
19512 return NULL;
19513 }
19514
19515
19516 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
19517 PyObject *resultobj = NULL;
19518 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19519 int arg2 ;
19520 PyObject * obj0 = 0 ;
19521 PyObject * obj1 = 0 ;
19522 char *kwnames[] = {
19523 (char *) "self",(char *) "m_x", NULL
19524 };
19525
19526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
19527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19528 if (SWIG_arg_fail(1)) SWIG_fail;
19529 {
19530 arg2 = static_cast<int >(SWIG_As_int(obj1));
19531 if (SWIG_arg_fail(2)) SWIG_fail;
19532 }
19533 if (arg1) (arg1)->m_x = arg2;
19534
19535 Py_INCREF(Py_None); resultobj = Py_None;
19536 return resultobj;
19537 fail:
19538 return NULL;
19539 }
19540
19541
19542 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
19543 PyObject *resultobj = NULL;
19544 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19545 int result;
19546 PyObject * obj0 = 0 ;
19547 char *kwnames[] = {
19548 (char *) "self", NULL
19549 };
19550
19551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
19552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19553 if (SWIG_arg_fail(1)) SWIG_fail;
19554 result = (int) ((arg1)->m_x);
19555
19556 {
19557 resultobj = SWIG_From_int(static_cast<int >(result));
19558 }
19559 return resultobj;
19560 fail:
19561 return NULL;
19562 }
19563
19564
19565 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
19566 PyObject *resultobj = NULL;
19567 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19568 int arg2 ;
19569 PyObject * obj0 = 0 ;
19570 PyObject * obj1 = 0 ;
19571 char *kwnames[] = {
19572 (char *) "self",(char *) "m_y", NULL
19573 };
19574
19575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
19576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19577 if (SWIG_arg_fail(1)) SWIG_fail;
19578 {
19579 arg2 = static_cast<int >(SWIG_As_int(obj1));
19580 if (SWIG_arg_fail(2)) SWIG_fail;
19581 }
19582 if (arg1) (arg1)->m_y = arg2;
19583
19584 Py_INCREF(Py_None); resultobj = Py_None;
19585 return resultobj;
19586 fail:
19587 return NULL;
19588 }
19589
19590
19591 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
19592 PyObject *resultobj = NULL;
19593 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19594 int result;
19595 PyObject * obj0 = 0 ;
19596 char *kwnames[] = {
19597 (char *) "self", NULL
19598 };
19599
19600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
19601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19602 if (SWIG_arg_fail(1)) SWIG_fail;
19603 result = (int) ((arg1)->m_y);
19604
19605 {
19606 resultobj = SWIG_From_int(static_cast<int >(result));
19607 }
19608 return resultobj;
19609 fail:
19610 return NULL;
19611 }
19612
19613
19614 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19615 PyObject *resultobj = NULL;
19616 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19617 long arg2 ;
19618 PyObject * obj0 = 0 ;
19619 PyObject * obj1 = 0 ;
19620 char *kwnames[] = {
19621 (char *) "self",(char *) "m_keyCode", NULL
19622 };
19623
19624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
19625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19626 if (SWIG_arg_fail(1)) SWIG_fail;
19627 {
19628 arg2 = static_cast<long >(SWIG_As_long(obj1));
19629 if (SWIG_arg_fail(2)) SWIG_fail;
19630 }
19631 if (arg1) (arg1)->m_keyCode = arg2;
19632
19633 Py_INCREF(Py_None); resultobj = Py_None;
19634 return resultobj;
19635 fail:
19636 return NULL;
19637 }
19638
19639
19640 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19641 PyObject *resultobj = NULL;
19642 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19643 long result;
19644 PyObject * obj0 = 0 ;
19645 char *kwnames[] = {
19646 (char *) "self", NULL
19647 };
19648
19649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
19650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19651 if (SWIG_arg_fail(1)) SWIG_fail;
19652 result = (long) ((arg1)->m_keyCode);
19653
19654 {
19655 resultobj = SWIG_From_long(static_cast<long >(result));
19656 }
19657 return resultobj;
19658 fail:
19659 return NULL;
19660 }
19661
19662
19663 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19664 PyObject *resultobj = NULL;
19665 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19666 bool arg2 ;
19667 PyObject * obj0 = 0 ;
19668 PyObject * obj1 = 0 ;
19669 char *kwnames[] = {
19670 (char *) "self",(char *) "m_controlDown", NULL
19671 };
19672
19673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
19674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19675 if (SWIG_arg_fail(1)) SWIG_fail;
19676 {
19677 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19678 if (SWIG_arg_fail(2)) SWIG_fail;
19679 }
19680 if (arg1) (arg1)->m_controlDown = arg2;
19681
19682 Py_INCREF(Py_None); resultobj = Py_None;
19683 return resultobj;
19684 fail:
19685 return NULL;
19686 }
19687
19688
19689 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19690 PyObject *resultobj = NULL;
19691 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19692 bool result;
19693 PyObject * obj0 = 0 ;
19694 char *kwnames[] = {
19695 (char *) "self", NULL
19696 };
19697
19698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
19699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19700 if (SWIG_arg_fail(1)) SWIG_fail;
19701 result = (bool) ((arg1)->m_controlDown);
19702
19703 {
19704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19705 }
19706 return resultobj;
19707 fail:
19708 return NULL;
19709 }
19710
19711
19712 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19713 PyObject *resultobj = NULL;
19714 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19715 bool arg2 ;
19716 PyObject * obj0 = 0 ;
19717 PyObject * obj1 = 0 ;
19718 char *kwnames[] = {
19719 (char *) "self",(char *) "m_shiftDown", NULL
19720 };
19721
19722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
19723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19724 if (SWIG_arg_fail(1)) SWIG_fail;
19725 {
19726 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19727 if (SWIG_arg_fail(2)) SWIG_fail;
19728 }
19729 if (arg1) (arg1)->m_shiftDown = arg2;
19730
19731 Py_INCREF(Py_None); resultobj = Py_None;
19732 return resultobj;
19733 fail:
19734 return NULL;
19735 }
19736
19737
19738 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19739 PyObject *resultobj = NULL;
19740 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19741 bool result;
19742 PyObject * obj0 = 0 ;
19743 char *kwnames[] = {
19744 (char *) "self", NULL
19745 };
19746
19747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
19748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19749 if (SWIG_arg_fail(1)) SWIG_fail;
19750 result = (bool) ((arg1)->m_shiftDown);
19751
19752 {
19753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19754 }
19755 return resultobj;
19756 fail:
19757 return NULL;
19758 }
19759
19760
19761 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19762 PyObject *resultobj = NULL;
19763 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19764 bool arg2 ;
19765 PyObject * obj0 = 0 ;
19766 PyObject * obj1 = 0 ;
19767 char *kwnames[] = {
19768 (char *) "self",(char *) "m_altDown", NULL
19769 };
19770
19771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19773 if (SWIG_arg_fail(1)) SWIG_fail;
19774 {
19775 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19776 if (SWIG_arg_fail(2)) SWIG_fail;
19777 }
19778 if (arg1) (arg1)->m_altDown = arg2;
19779
19780 Py_INCREF(Py_None); resultobj = Py_None;
19781 return resultobj;
19782 fail:
19783 return NULL;
19784 }
19785
19786
19787 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19788 PyObject *resultobj = NULL;
19789 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19790 bool result;
19791 PyObject * obj0 = 0 ;
19792 char *kwnames[] = {
19793 (char *) "self", NULL
19794 };
19795
19796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19798 if (SWIG_arg_fail(1)) SWIG_fail;
19799 result = (bool) ((arg1)->m_altDown);
19800
19801 {
19802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19803 }
19804 return resultobj;
19805 fail:
19806 return NULL;
19807 }
19808
19809
19810 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19811 PyObject *resultobj = NULL;
19812 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19813 bool arg2 ;
19814 PyObject * obj0 = 0 ;
19815 PyObject * obj1 = 0 ;
19816 char *kwnames[] = {
19817 (char *) "self",(char *) "m_metaDown", NULL
19818 };
19819
19820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19822 if (SWIG_arg_fail(1)) SWIG_fail;
19823 {
19824 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19825 if (SWIG_arg_fail(2)) SWIG_fail;
19826 }
19827 if (arg1) (arg1)->m_metaDown = arg2;
19828
19829 Py_INCREF(Py_None); resultobj = Py_None;
19830 return resultobj;
19831 fail:
19832 return NULL;
19833 }
19834
19835
19836 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19837 PyObject *resultobj = NULL;
19838 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19839 bool result;
19840 PyObject * obj0 = 0 ;
19841 char *kwnames[] = {
19842 (char *) "self", NULL
19843 };
19844
19845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19847 if (SWIG_arg_fail(1)) SWIG_fail;
19848 result = (bool) ((arg1)->m_metaDown);
19849
19850 {
19851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19852 }
19853 return resultobj;
19854 fail:
19855 return NULL;
19856 }
19857
19858
19859 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19860 PyObject *resultobj = NULL;
19861 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19862 bool arg2 ;
19863 PyObject * obj0 = 0 ;
19864 PyObject * obj1 = 0 ;
19865 char *kwnames[] = {
19866 (char *) "self",(char *) "m_scanCode", NULL
19867 };
19868
19869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19871 if (SWIG_arg_fail(1)) SWIG_fail;
19872 {
19873 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19874 if (SWIG_arg_fail(2)) SWIG_fail;
19875 }
19876 if (arg1) (arg1)->m_scanCode = arg2;
19877
19878 Py_INCREF(Py_None); resultobj = Py_None;
19879 return resultobj;
19880 fail:
19881 return NULL;
19882 }
19883
19884
19885 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19886 PyObject *resultobj = NULL;
19887 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19888 bool result;
19889 PyObject * obj0 = 0 ;
19890 char *kwnames[] = {
19891 (char *) "self", NULL
19892 };
19893
19894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19896 if (SWIG_arg_fail(1)) SWIG_fail;
19897 result = (bool) ((arg1)->m_scanCode);
19898
19899 {
19900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19901 }
19902 return resultobj;
19903 fail:
19904 return NULL;
19905 }
19906
19907
19908 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19909 PyObject *resultobj = NULL;
19910 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19911 unsigned int arg2 ;
19912 PyObject * obj0 = 0 ;
19913 PyObject * obj1 = 0 ;
19914 char *kwnames[] = {
19915 (char *) "self",(char *) "m_rawCode", NULL
19916 };
19917
19918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19920 if (SWIG_arg_fail(1)) SWIG_fail;
19921 {
19922 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
19923 if (SWIG_arg_fail(2)) SWIG_fail;
19924 }
19925 if (arg1) (arg1)->m_rawCode = arg2;
19926
19927 Py_INCREF(Py_None); resultobj = Py_None;
19928 return resultobj;
19929 fail:
19930 return NULL;
19931 }
19932
19933
19934 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19935 PyObject *resultobj = NULL;
19936 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19937 unsigned int result;
19938 PyObject * obj0 = 0 ;
19939 char *kwnames[] = {
19940 (char *) "self", NULL
19941 };
19942
19943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19945 if (SWIG_arg_fail(1)) SWIG_fail;
19946 result = (unsigned int) ((arg1)->m_rawCode);
19947
19948 {
19949 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19950 }
19951 return resultobj;
19952 fail:
19953 return NULL;
19954 }
19955
19956
19957 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19958 PyObject *resultobj = NULL;
19959 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19960 unsigned int arg2 ;
19961 PyObject * obj0 = 0 ;
19962 PyObject * obj1 = 0 ;
19963 char *kwnames[] = {
19964 (char *) "self",(char *) "m_rawFlags", NULL
19965 };
19966
19967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19969 if (SWIG_arg_fail(1)) SWIG_fail;
19970 {
19971 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
19972 if (SWIG_arg_fail(2)) SWIG_fail;
19973 }
19974 if (arg1) (arg1)->m_rawFlags = arg2;
19975
19976 Py_INCREF(Py_None); resultobj = Py_None;
19977 return resultobj;
19978 fail:
19979 return NULL;
19980 }
19981
19982
19983 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19984 PyObject *resultobj = NULL;
19985 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19986 unsigned int result;
19987 PyObject * obj0 = 0 ;
19988 char *kwnames[] = {
19989 (char *) "self", NULL
19990 };
19991
19992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19994 if (SWIG_arg_fail(1)) SWIG_fail;
19995 result = (unsigned int) ((arg1)->m_rawFlags);
19996
19997 {
19998 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19999 }
20000 return resultobj;
20001 fail:
20002 return NULL;
20003 }
20004
20005
20006 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
20007 PyObject *obj;
20008 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20009 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
20010 Py_INCREF(obj);
20011 return Py_BuildValue((char *)"");
20012 }
20013 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20014 PyObject *resultobj = NULL;
20015 wxSize const &arg1_defvalue = wxDefaultSize ;
20016 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
20017 int arg2 = (int) 0 ;
20018 wxSizeEvent *result;
20019 wxSize temp1 ;
20020 PyObject * obj0 = 0 ;
20021 PyObject * obj1 = 0 ;
20022 char *kwnames[] = {
20023 (char *) "sz",(char *) "winid", NULL
20024 };
20025
20026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
20027 if (obj0) {
20028 {
20029 arg1 = &temp1;
20030 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
20031 }
20032 }
20033 if (obj1) {
20034 {
20035 arg2 = static_cast<int >(SWIG_As_int(obj1));
20036 if (SWIG_arg_fail(2)) SWIG_fail;
20037 }
20038 }
20039 {
20040 PyThreadState* __tstate = wxPyBeginAllowThreads();
20041 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
20042
20043 wxPyEndAllowThreads(__tstate);
20044 if (PyErr_Occurred()) SWIG_fail;
20045 }
20046 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
20047 return resultobj;
20048 fail:
20049 return NULL;
20050 }
20051
20052
20053 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
20054 PyObject *resultobj = NULL;
20055 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20056 wxSize result;
20057 PyObject * obj0 = 0 ;
20058 char *kwnames[] = {
20059 (char *) "self", NULL
20060 };
20061
20062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
20063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20064 if (SWIG_arg_fail(1)) SWIG_fail;
20065 {
20066 PyThreadState* __tstate = wxPyBeginAllowThreads();
20067 result = ((wxSizeEvent const *)arg1)->GetSize();
20068
20069 wxPyEndAllowThreads(__tstate);
20070 if (PyErr_Occurred()) SWIG_fail;
20071 }
20072 {
20073 wxSize * resultptr;
20074 resultptr = new wxSize(static_cast<wxSize & >(result));
20075 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20076 }
20077 return resultobj;
20078 fail:
20079 return NULL;
20080 }
20081
20082
20083 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20084 PyObject *resultobj = NULL;
20085 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20086 wxRect result;
20087 PyObject * obj0 = 0 ;
20088 char *kwnames[] = {
20089 (char *) "self", NULL
20090 };
20091
20092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
20093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20094 if (SWIG_arg_fail(1)) SWIG_fail;
20095 {
20096 PyThreadState* __tstate = wxPyBeginAllowThreads();
20097 result = ((wxSizeEvent const *)arg1)->GetRect();
20098
20099 wxPyEndAllowThreads(__tstate);
20100 if (PyErr_Occurred()) SWIG_fail;
20101 }
20102 {
20103 wxRect * resultptr;
20104 resultptr = new wxRect(static_cast<wxRect & >(result));
20105 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20106 }
20107 return resultobj;
20108 fail:
20109 return NULL;
20110 }
20111
20112
20113 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20114 PyObject *resultobj = NULL;
20115 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20116 wxRect arg2 ;
20117 PyObject * obj0 = 0 ;
20118 PyObject * obj1 = 0 ;
20119 char *kwnames[] = {
20120 (char *) "self",(char *) "rect", NULL
20121 };
20122
20123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20125 if (SWIG_arg_fail(1)) SWIG_fail;
20126 {
20127 wxRect * argp;
20128 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
20129 if (SWIG_arg_fail(2)) SWIG_fail;
20130 if (argp == NULL) {
20131 SWIG_null_ref("wxRect");
20132 }
20133 if (SWIG_arg_fail(2)) SWIG_fail;
20134 arg2 = *argp;
20135 }
20136 {
20137 PyThreadState* __tstate = wxPyBeginAllowThreads();
20138 (arg1)->SetRect(arg2);
20139
20140 wxPyEndAllowThreads(__tstate);
20141 if (PyErr_Occurred()) SWIG_fail;
20142 }
20143 Py_INCREF(Py_None); resultobj = Py_None;
20144 return resultobj;
20145 fail:
20146 return NULL;
20147 }
20148
20149
20150 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
20151 PyObject *resultobj = NULL;
20152 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20153 wxSize arg2 ;
20154 PyObject * obj0 = 0 ;
20155 PyObject * obj1 = 0 ;
20156 char *kwnames[] = {
20157 (char *) "self",(char *) "size", NULL
20158 };
20159
20160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
20161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20162 if (SWIG_arg_fail(1)) SWIG_fail;
20163 {
20164 wxSize * argp;
20165 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
20166 if (SWIG_arg_fail(2)) SWIG_fail;
20167 if (argp == NULL) {
20168 SWIG_null_ref("wxSize");
20169 }
20170 if (SWIG_arg_fail(2)) SWIG_fail;
20171 arg2 = *argp;
20172 }
20173 {
20174 PyThreadState* __tstate = wxPyBeginAllowThreads();
20175 wxSizeEvent_SetSize(arg1,arg2);
20176
20177 wxPyEndAllowThreads(__tstate);
20178 if (PyErr_Occurred()) SWIG_fail;
20179 }
20180 Py_INCREF(Py_None); resultobj = Py_None;
20181 return resultobj;
20182 fail:
20183 return NULL;
20184 }
20185
20186
20187 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
20188 PyObject *resultobj = NULL;
20189 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20190 wxSize *arg2 = (wxSize *) 0 ;
20191 PyObject * obj0 = 0 ;
20192 PyObject * obj1 = 0 ;
20193 char *kwnames[] = {
20194 (char *) "self",(char *) "m_size", NULL
20195 };
20196
20197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
20198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20199 if (SWIG_arg_fail(1)) SWIG_fail;
20200 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
20201 if (SWIG_arg_fail(2)) SWIG_fail;
20202 if (arg1) (arg1)->m_size = *arg2;
20203
20204 Py_INCREF(Py_None); resultobj = Py_None;
20205 return resultobj;
20206 fail:
20207 return NULL;
20208 }
20209
20210
20211 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
20212 PyObject *resultobj = NULL;
20213 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20214 wxSize *result;
20215 PyObject * obj0 = 0 ;
20216 char *kwnames[] = {
20217 (char *) "self", NULL
20218 };
20219
20220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
20221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20222 if (SWIG_arg_fail(1)) SWIG_fail;
20223 result = (wxSize *)& ((arg1)->m_size);
20224
20225 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
20226 return resultobj;
20227 fail:
20228 return NULL;
20229 }
20230
20231
20232 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
20233 PyObject *resultobj = NULL;
20234 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20235 wxRect *arg2 = (wxRect *) 0 ;
20236 PyObject * obj0 = 0 ;
20237 PyObject * obj1 = 0 ;
20238 char *kwnames[] = {
20239 (char *) "self",(char *) "m_rect", NULL
20240 };
20241
20242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
20243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20244 if (SWIG_arg_fail(1)) SWIG_fail;
20245 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
20246 if (SWIG_arg_fail(2)) SWIG_fail;
20247 if (arg1) (arg1)->m_rect = *arg2;
20248
20249 Py_INCREF(Py_None); resultobj = Py_None;
20250 return resultobj;
20251 fail:
20252 return NULL;
20253 }
20254
20255
20256 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
20257 PyObject *resultobj = NULL;
20258 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20259 wxRect *result;
20260 PyObject * obj0 = 0 ;
20261 char *kwnames[] = {
20262 (char *) "self", NULL
20263 };
20264
20265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
20266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20267 if (SWIG_arg_fail(1)) SWIG_fail;
20268 result = (wxRect *)& ((arg1)->m_rect);
20269
20270 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
20271 return resultobj;
20272 fail:
20273 return NULL;
20274 }
20275
20276
20277 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
20278 PyObject *obj;
20279 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20280 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
20281 Py_INCREF(obj);
20282 return Py_BuildValue((char *)"");
20283 }
20284 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20285 PyObject *resultobj = NULL;
20286 wxPoint const &arg1_defvalue = wxDefaultPosition ;
20287 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
20288 int arg2 = (int) 0 ;
20289 wxMoveEvent *result;
20290 wxPoint temp1 ;
20291 PyObject * obj0 = 0 ;
20292 PyObject * obj1 = 0 ;
20293 char *kwnames[] = {
20294 (char *) "pos",(char *) "winid", NULL
20295 };
20296
20297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
20298 if (obj0) {
20299 {
20300 arg1 = &temp1;
20301 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
20302 }
20303 }
20304 if (obj1) {
20305 {
20306 arg2 = static_cast<int >(SWIG_As_int(obj1));
20307 if (SWIG_arg_fail(2)) SWIG_fail;
20308 }
20309 }
20310 {
20311 PyThreadState* __tstate = wxPyBeginAllowThreads();
20312 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
20313
20314 wxPyEndAllowThreads(__tstate);
20315 if (PyErr_Occurred()) SWIG_fail;
20316 }
20317 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
20318 return resultobj;
20319 fail:
20320 return NULL;
20321 }
20322
20323
20324 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20325 PyObject *resultobj = NULL;
20326 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20327 wxPoint result;
20328 PyObject * obj0 = 0 ;
20329 char *kwnames[] = {
20330 (char *) "self", NULL
20331 };
20332
20333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
20334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20335 if (SWIG_arg_fail(1)) SWIG_fail;
20336 {
20337 PyThreadState* __tstate = wxPyBeginAllowThreads();
20338 result = ((wxMoveEvent const *)arg1)->GetPosition();
20339
20340 wxPyEndAllowThreads(__tstate);
20341 if (PyErr_Occurred()) SWIG_fail;
20342 }
20343 {
20344 wxPoint * resultptr;
20345 resultptr = new wxPoint(static_cast<wxPoint & >(result));
20346 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20347 }
20348 return resultobj;
20349 fail:
20350 return NULL;
20351 }
20352
20353
20354 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20355 PyObject *resultobj = NULL;
20356 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20357 wxRect result;
20358 PyObject * obj0 = 0 ;
20359 char *kwnames[] = {
20360 (char *) "self", NULL
20361 };
20362
20363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
20364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20365 if (SWIG_arg_fail(1)) SWIG_fail;
20366 {
20367 PyThreadState* __tstate = wxPyBeginAllowThreads();
20368 result = ((wxMoveEvent const *)arg1)->GetRect();
20369
20370 wxPyEndAllowThreads(__tstate);
20371 if (PyErr_Occurred()) SWIG_fail;
20372 }
20373 {
20374 wxRect * resultptr;
20375 resultptr = new wxRect(static_cast<wxRect & >(result));
20376 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20377 }
20378 return resultobj;
20379 fail:
20380 return NULL;
20381 }
20382
20383
20384 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20385 PyObject *resultobj = NULL;
20386 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20387 wxRect *arg2 = 0 ;
20388 wxRect temp2 ;
20389 PyObject * obj0 = 0 ;
20390 PyObject * obj1 = 0 ;
20391 char *kwnames[] = {
20392 (char *) "self",(char *) "rect", NULL
20393 };
20394
20395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20397 if (SWIG_arg_fail(1)) SWIG_fail;
20398 {
20399 arg2 = &temp2;
20400 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20401 }
20402 {
20403 PyThreadState* __tstate = wxPyBeginAllowThreads();
20404 (arg1)->SetRect((wxRect const &)*arg2);
20405
20406 wxPyEndAllowThreads(__tstate);
20407 if (PyErr_Occurred()) SWIG_fail;
20408 }
20409 Py_INCREF(Py_None); resultobj = Py_None;
20410 return resultobj;
20411 fail:
20412 return NULL;
20413 }
20414
20415
20416 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20417 PyObject *resultobj = NULL;
20418 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20419 wxPoint *arg2 = 0 ;
20420 wxPoint temp2 ;
20421 PyObject * obj0 = 0 ;
20422 PyObject * obj1 = 0 ;
20423 char *kwnames[] = {
20424 (char *) "self",(char *) "pos", NULL
20425 };
20426
20427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
20428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20429 if (SWIG_arg_fail(1)) SWIG_fail;
20430 {
20431 arg2 = &temp2;
20432 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
20433 }
20434 {
20435 PyThreadState* __tstate = wxPyBeginAllowThreads();
20436 (arg1)->SetPosition((wxPoint const &)*arg2);
20437
20438 wxPyEndAllowThreads(__tstate);
20439 if (PyErr_Occurred()) SWIG_fail;
20440 }
20441 Py_INCREF(Py_None); resultobj = Py_None;
20442 return resultobj;
20443 fail:
20444 return NULL;
20445 }
20446
20447
20448 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
20449 PyObject *obj;
20450 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20451 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
20452 Py_INCREF(obj);
20453 return Py_BuildValue((char *)"");
20454 }
20455 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20456 PyObject *resultobj = NULL;
20457 int arg1 = (int) 0 ;
20458 wxPaintEvent *result;
20459 PyObject * obj0 = 0 ;
20460 char *kwnames[] = {
20461 (char *) "Id", NULL
20462 };
20463
20464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
20465 if (obj0) {
20466 {
20467 arg1 = static_cast<int >(SWIG_As_int(obj0));
20468 if (SWIG_arg_fail(1)) SWIG_fail;
20469 }
20470 }
20471 {
20472 PyThreadState* __tstate = wxPyBeginAllowThreads();
20473 result = (wxPaintEvent *)new wxPaintEvent(arg1);
20474
20475 wxPyEndAllowThreads(__tstate);
20476 if (PyErr_Occurred()) SWIG_fail;
20477 }
20478 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
20479 return resultobj;
20480 fail:
20481 return NULL;
20482 }
20483
20484
20485 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
20486 PyObject *obj;
20487 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20488 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
20489 Py_INCREF(obj);
20490 return Py_BuildValue((char *)"");
20491 }
20492 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20493 PyObject *resultobj = NULL;
20494 int arg1 = (int) 0 ;
20495 wxNcPaintEvent *result;
20496 PyObject * obj0 = 0 ;
20497 char *kwnames[] = {
20498 (char *) "winid", NULL
20499 };
20500
20501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
20502 if (obj0) {
20503 {
20504 arg1 = static_cast<int >(SWIG_As_int(obj0));
20505 if (SWIG_arg_fail(1)) SWIG_fail;
20506 }
20507 }
20508 {
20509 PyThreadState* __tstate = wxPyBeginAllowThreads();
20510 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
20511
20512 wxPyEndAllowThreads(__tstate);
20513 if (PyErr_Occurred()) SWIG_fail;
20514 }
20515 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
20516 return resultobj;
20517 fail:
20518 return NULL;
20519 }
20520
20521
20522 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
20523 PyObject *obj;
20524 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20525 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
20526 Py_INCREF(obj);
20527 return Py_BuildValue((char *)"");
20528 }
20529 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20530 PyObject *resultobj = NULL;
20531 int arg1 = (int) 0 ;
20532 wxDC *arg2 = (wxDC *) NULL ;
20533 wxEraseEvent *result;
20534 PyObject * obj0 = 0 ;
20535 PyObject * obj1 = 0 ;
20536 char *kwnames[] = {
20537 (char *) "Id",(char *) "dc", NULL
20538 };
20539
20540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
20541 if (obj0) {
20542 {
20543 arg1 = static_cast<int >(SWIG_As_int(obj0));
20544 if (SWIG_arg_fail(1)) SWIG_fail;
20545 }
20546 }
20547 if (obj1) {
20548 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20549 if (SWIG_arg_fail(2)) SWIG_fail;
20550 }
20551 {
20552 PyThreadState* __tstate = wxPyBeginAllowThreads();
20553 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
20554
20555 wxPyEndAllowThreads(__tstate);
20556 if (PyErr_Occurred()) SWIG_fail;
20557 }
20558 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
20559 return resultobj;
20560 fail:
20561 return NULL;
20562 }
20563
20564
20565 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
20566 PyObject *resultobj = NULL;
20567 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
20568 wxDC *result;
20569 PyObject * obj0 = 0 ;
20570 char *kwnames[] = {
20571 (char *) "self", NULL
20572 };
20573
20574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
20575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
20576 if (SWIG_arg_fail(1)) SWIG_fail;
20577 {
20578 PyThreadState* __tstate = wxPyBeginAllowThreads();
20579 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
20580
20581 wxPyEndAllowThreads(__tstate);
20582 if (PyErr_Occurred()) SWIG_fail;
20583 }
20584 {
20585 resultobj = wxPyMake_wxObject(result, 0);
20586 }
20587 return resultobj;
20588 fail:
20589 return NULL;
20590 }
20591
20592
20593 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
20594 PyObject *obj;
20595 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20596 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
20597 Py_INCREF(obj);
20598 return Py_BuildValue((char *)"");
20599 }
20600 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20601 PyObject *resultobj = NULL;
20602 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20603 int arg2 = (int) 0 ;
20604 wxFocusEvent *result;
20605 PyObject * obj0 = 0 ;
20606 PyObject * obj1 = 0 ;
20607 char *kwnames[] = {
20608 (char *) "type",(char *) "winid", NULL
20609 };
20610
20611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
20612 if (obj0) {
20613 {
20614 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20615 if (SWIG_arg_fail(1)) SWIG_fail;
20616 }
20617 }
20618 if (obj1) {
20619 {
20620 arg2 = static_cast<int >(SWIG_As_int(obj1));
20621 if (SWIG_arg_fail(2)) SWIG_fail;
20622 }
20623 }
20624 {
20625 PyThreadState* __tstate = wxPyBeginAllowThreads();
20626 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
20627
20628 wxPyEndAllowThreads(__tstate);
20629 if (PyErr_Occurred()) SWIG_fail;
20630 }
20631 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
20632 return resultobj;
20633 fail:
20634 return NULL;
20635 }
20636
20637
20638 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20639 PyObject *resultobj = NULL;
20640 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20641 wxWindow *result;
20642 PyObject * obj0 = 0 ;
20643 char *kwnames[] = {
20644 (char *) "self", NULL
20645 };
20646
20647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20649 if (SWIG_arg_fail(1)) SWIG_fail;
20650 {
20651 PyThreadState* __tstate = wxPyBeginAllowThreads();
20652 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
20653
20654 wxPyEndAllowThreads(__tstate);
20655 if (PyErr_Occurred()) SWIG_fail;
20656 }
20657 {
20658 resultobj = wxPyMake_wxObject(result, 0);
20659 }
20660 return resultobj;
20661 fail:
20662 return NULL;
20663 }
20664
20665
20666 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20667 PyObject *resultobj = NULL;
20668 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20669 wxWindow *arg2 = (wxWindow *) 0 ;
20670 PyObject * obj0 = 0 ;
20671 PyObject * obj1 = 0 ;
20672 char *kwnames[] = {
20673 (char *) "self",(char *) "win", NULL
20674 };
20675
20676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
20677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20678 if (SWIG_arg_fail(1)) SWIG_fail;
20679 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20680 if (SWIG_arg_fail(2)) SWIG_fail;
20681 {
20682 PyThreadState* __tstate = wxPyBeginAllowThreads();
20683 (arg1)->SetWindow(arg2);
20684
20685 wxPyEndAllowThreads(__tstate);
20686 if (PyErr_Occurred()) SWIG_fail;
20687 }
20688 Py_INCREF(Py_None); resultobj = Py_None;
20689 return resultobj;
20690 fail:
20691 return NULL;
20692 }
20693
20694
20695 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
20696 PyObject *obj;
20697 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20698 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
20699 Py_INCREF(obj);
20700 return Py_BuildValue((char *)"");
20701 }
20702 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20703 PyObject *resultobj = NULL;
20704 wxWindow *arg1 = (wxWindow *) NULL ;
20705 wxChildFocusEvent *result;
20706 PyObject * obj0 = 0 ;
20707 char *kwnames[] = {
20708 (char *) "win", NULL
20709 };
20710
20711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
20712 if (obj0) {
20713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20714 if (SWIG_arg_fail(1)) SWIG_fail;
20715 }
20716 {
20717 PyThreadState* __tstate = wxPyBeginAllowThreads();
20718 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
20719
20720 wxPyEndAllowThreads(__tstate);
20721 if (PyErr_Occurred()) SWIG_fail;
20722 }
20723 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
20724 return resultobj;
20725 fail:
20726 return NULL;
20727 }
20728
20729
20730 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20731 PyObject *resultobj = NULL;
20732 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
20733 wxWindow *result;
20734 PyObject * obj0 = 0 ;
20735 char *kwnames[] = {
20736 (char *) "self", NULL
20737 };
20738
20739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20741 if (SWIG_arg_fail(1)) SWIG_fail;
20742 {
20743 PyThreadState* __tstate = wxPyBeginAllowThreads();
20744 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
20745
20746 wxPyEndAllowThreads(__tstate);
20747 if (PyErr_Occurred()) SWIG_fail;
20748 }
20749 {
20750 resultobj = wxPyMake_wxObject(result, 0);
20751 }
20752 return resultobj;
20753 fail:
20754 return NULL;
20755 }
20756
20757
20758 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
20759 PyObject *obj;
20760 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20761 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
20762 Py_INCREF(obj);
20763 return Py_BuildValue((char *)"");
20764 }
20765 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20766 PyObject *resultobj = NULL;
20767 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20768 bool arg2 = (bool) true ;
20769 int arg3 = (int) 0 ;
20770 wxActivateEvent *result;
20771 PyObject * obj0 = 0 ;
20772 PyObject * obj1 = 0 ;
20773 PyObject * obj2 = 0 ;
20774 char *kwnames[] = {
20775 (char *) "type",(char *) "active",(char *) "Id", NULL
20776 };
20777
20778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20779 if (obj0) {
20780 {
20781 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20782 if (SWIG_arg_fail(1)) SWIG_fail;
20783 }
20784 }
20785 if (obj1) {
20786 {
20787 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
20788 if (SWIG_arg_fail(2)) SWIG_fail;
20789 }
20790 }
20791 if (obj2) {
20792 {
20793 arg3 = static_cast<int >(SWIG_As_int(obj2));
20794 if (SWIG_arg_fail(3)) SWIG_fail;
20795 }
20796 }
20797 {
20798 PyThreadState* __tstate = wxPyBeginAllowThreads();
20799 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20800
20801 wxPyEndAllowThreads(__tstate);
20802 if (PyErr_Occurred()) SWIG_fail;
20803 }
20804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20805 return resultobj;
20806 fail:
20807 return NULL;
20808 }
20809
20810
20811 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20812 PyObject *resultobj = NULL;
20813 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20814 bool result;
20815 PyObject * obj0 = 0 ;
20816 char *kwnames[] = {
20817 (char *) "self", NULL
20818 };
20819
20820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20822 if (SWIG_arg_fail(1)) SWIG_fail;
20823 {
20824 PyThreadState* __tstate = wxPyBeginAllowThreads();
20825 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20826
20827 wxPyEndAllowThreads(__tstate);
20828 if (PyErr_Occurred()) SWIG_fail;
20829 }
20830 {
20831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20832 }
20833 return resultobj;
20834 fail:
20835 return NULL;
20836 }
20837
20838
20839 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20840 PyObject *obj;
20841 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20842 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20843 Py_INCREF(obj);
20844 return Py_BuildValue((char *)"");
20845 }
20846 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20847 PyObject *resultobj = NULL;
20848 int arg1 = (int) 0 ;
20849 wxInitDialogEvent *result;
20850 PyObject * obj0 = 0 ;
20851 char *kwnames[] = {
20852 (char *) "Id", NULL
20853 };
20854
20855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20856 if (obj0) {
20857 {
20858 arg1 = static_cast<int >(SWIG_As_int(obj0));
20859 if (SWIG_arg_fail(1)) SWIG_fail;
20860 }
20861 }
20862 {
20863 PyThreadState* __tstate = wxPyBeginAllowThreads();
20864 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20865
20866 wxPyEndAllowThreads(__tstate);
20867 if (PyErr_Occurred()) SWIG_fail;
20868 }
20869 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20870 return resultobj;
20871 fail:
20872 return NULL;
20873 }
20874
20875
20876 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20877 PyObject *obj;
20878 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20879 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20880 Py_INCREF(obj);
20881 return Py_BuildValue((char *)"");
20882 }
20883 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20884 PyObject *resultobj = NULL;
20885 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20886 int arg2 = (int) 0 ;
20887 wxMenu *arg3 = (wxMenu *) NULL ;
20888 wxMenuEvent *result;
20889 PyObject * obj0 = 0 ;
20890 PyObject * obj1 = 0 ;
20891 PyObject * obj2 = 0 ;
20892 char *kwnames[] = {
20893 (char *) "type",(char *) "winid",(char *) "menu", NULL
20894 };
20895
20896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20897 if (obj0) {
20898 {
20899 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20900 if (SWIG_arg_fail(1)) SWIG_fail;
20901 }
20902 }
20903 if (obj1) {
20904 {
20905 arg2 = static_cast<int >(SWIG_As_int(obj1));
20906 if (SWIG_arg_fail(2)) SWIG_fail;
20907 }
20908 }
20909 if (obj2) {
20910 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20911 if (SWIG_arg_fail(3)) SWIG_fail;
20912 }
20913 {
20914 PyThreadState* __tstate = wxPyBeginAllowThreads();
20915 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20916
20917 wxPyEndAllowThreads(__tstate);
20918 if (PyErr_Occurred()) SWIG_fail;
20919 }
20920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20921 return resultobj;
20922 fail:
20923 return NULL;
20924 }
20925
20926
20927 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20928 PyObject *resultobj = NULL;
20929 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20930 int result;
20931 PyObject * obj0 = 0 ;
20932 char *kwnames[] = {
20933 (char *) "self", NULL
20934 };
20935
20936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20938 if (SWIG_arg_fail(1)) SWIG_fail;
20939 {
20940 PyThreadState* __tstate = wxPyBeginAllowThreads();
20941 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20942
20943 wxPyEndAllowThreads(__tstate);
20944 if (PyErr_Occurred()) SWIG_fail;
20945 }
20946 {
20947 resultobj = SWIG_From_int(static_cast<int >(result));
20948 }
20949 return resultobj;
20950 fail:
20951 return NULL;
20952 }
20953
20954
20955 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20956 PyObject *resultobj = NULL;
20957 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20958 bool result;
20959 PyObject * obj0 = 0 ;
20960 char *kwnames[] = {
20961 (char *) "self", NULL
20962 };
20963
20964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20966 if (SWIG_arg_fail(1)) SWIG_fail;
20967 {
20968 PyThreadState* __tstate = wxPyBeginAllowThreads();
20969 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20970
20971 wxPyEndAllowThreads(__tstate);
20972 if (PyErr_Occurred()) SWIG_fail;
20973 }
20974 {
20975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20976 }
20977 return resultobj;
20978 fail:
20979 return NULL;
20980 }
20981
20982
20983 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20984 PyObject *resultobj = NULL;
20985 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20986 wxMenu *result;
20987 PyObject * obj0 = 0 ;
20988 char *kwnames[] = {
20989 (char *) "self", NULL
20990 };
20991
20992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20994 if (SWIG_arg_fail(1)) SWIG_fail;
20995 {
20996 PyThreadState* __tstate = wxPyBeginAllowThreads();
20997 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20998
20999 wxPyEndAllowThreads(__tstate);
21000 if (PyErr_Occurred()) SWIG_fail;
21001 }
21002 {
21003 resultobj = wxPyMake_wxObject(result, 0);
21004 }
21005 return resultobj;
21006 fail:
21007 return NULL;
21008 }
21009
21010
21011 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
21012 PyObject *obj;
21013 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21014 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
21015 Py_INCREF(obj);
21016 return Py_BuildValue((char *)"");
21017 }
21018 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21019 PyObject *resultobj = NULL;
21020 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21021 int arg2 = (int) 0 ;
21022 wxCloseEvent *result;
21023 PyObject * obj0 = 0 ;
21024 PyObject * obj1 = 0 ;
21025 char *kwnames[] = {
21026 (char *) "type",(char *) "winid", NULL
21027 };
21028
21029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
21030 if (obj0) {
21031 {
21032 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
21033 if (SWIG_arg_fail(1)) SWIG_fail;
21034 }
21035 }
21036 if (obj1) {
21037 {
21038 arg2 = static_cast<int >(SWIG_As_int(obj1));
21039 if (SWIG_arg_fail(2)) SWIG_fail;
21040 }
21041 }
21042 {
21043 PyThreadState* __tstate = wxPyBeginAllowThreads();
21044 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
21045
21046 wxPyEndAllowThreads(__tstate);
21047 if (PyErr_Occurred()) SWIG_fail;
21048 }
21049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
21050 return resultobj;
21051 fail:
21052 return NULL;
21053 }
21054
21055
21056 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
21057 PyObject *resultobj = NULL;
21058 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21059 bool arg2 ;
21060 PyObject * obj0 = 0 ;
21061 PyObject * obj1 = 0 ;
21062 char *kwnames[] = {
21063 (char *) "self",(char *) "logOff", NULL
21064 };
21065
21066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
21067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21068 if (SWIG_arg_fail(1)) SWIG_fail;
21069 {
21070 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21071 if (SWIG_arg_fail(2)) SWIG_fail;
21072 }
21073 {
21074 PyThreadState* __tstate = wxPyBeginAllowThreads();
21075 (arg1)->SetLoggingOff(arg2);
21076
21077 wxPyEndAllowThreads(__tstate);
21078 if (PyErr_Occurred()) SWIG_fail;
21079 }
21080 Py_INCREF(Py_None); resultobj = Py_None;
21081 return resultobj;
21082 fail:
21083 return NULL;
21084 }
21085
21086
21087 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
21088 PyObject *resultobj = NULL;
21089 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21090 bool result;
21091 PyObject * obj0 = 0 ;
21092 char *kwnames[] = {
21093 (char *) "self", NULL
21094 };
21095
21096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
21097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21098 if (SWIG_arg_fail(1)) SWIG_fail;
21099 {
21100 PyThreadState* __tstate = wxPyBeginAllowThreads();
21101 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
21102
21103 wxPyEndAllowThreads(__tstate);
21104 if (PyErr_Occurred()) SWIG_fail;
21105 }
21106 {
21107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21108 }
21109 return resultobj;
21110 fail:
21111 return NULL;
21112 }
21113
21114
21115 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
21116 PyObject *resultobj = NULL;
21117 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21118 bool arg2 = (bool) true ;
21119 PyObject * obj0 = 0 ;
21120 PyObject * obj1 = 0 ;
21121 char *kwnames[] = {
21122 (char *) "self",(char *) "veto", NULL
21123 };
21124
21125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
21126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21127 if (SWIG_arg_fail(1)) SWIG_fail;
21128 if (obj1) {
21129 {
21130 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21131 if (SWIG_arg_fail(2)) SWIG_fail;
21132 }
21133 }
21134 {
21135 PyThreadState* __tstate = wxPyBeginAllowThreads();
21136 (arg1)->Veto(arg2);
21137
21138 wxPyEndAllowThreads(__tstate);
21139 if (PyErr_Occurred()) SWIG_fail;
21140 }
21141 Py_INCREF(Py_None); resultobj = Py_None;
21142 return resultobj;
21143 fail:
21144 return NULL;
21145 }
21146
21147
21148 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21149 PyObject *resultobj = NULL;
21150 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21151 bool result;
21152 PyObject * obj0 = 0 ;
21153 char *kwnames[] = {
21154 (char *) "self", NULL
21155 };
21156
21157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
21158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21159 if (SWIG_arg_fail(1)) SWIG_fail;
21160 {
21161 PyThreadState* __tstate = wxPyBeginAllowThreads();
21162 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
21163
21164 wxPyEndAllowThreads(__tstate);
21165 if (PyErr_Occurred()) SWIG_fail;
21166 }
21167 {
21168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21169 }
21170 return resultobj;
21171 fail:
21172 return NULL;
21173 }
21174
21175
21176 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21177 PyObject *resultobj = NULL;
21178 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21179 bool arg2 ;
21180 PyObject * obj0 = 0 ;
21181 PyObject * obj1 = 0 ;
21182 char *kwnames[] = {
21183 (char *) "self",(char *) "canVeto", NULL
21184 };
21185
21186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
21187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21188 if (SWIG_arg_fail(1)) SWIG_fail;
21189 {
21190 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21191 if (SWIG_arg_fail(2)) SWIG_fail;
21192 }
21193 {
21194 PyThreadState* __tstate = wxPyBeginAllowThreads();
21195 (arg1)->SetCanVeto(arg2);
21196
21197 wxPyEndAllowThreads(__tstate);
21198 if (PyErr_Occurred()) SWIG_fail;
21199 }
21200 Py_INCREF(Py_None); resultobj = Py_None;
21201 return resultobj;
21202 fail:
21203 return NULL;
21204 }
21205
21206
21207 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21208 PyObject *resultobj = NULL;
21209 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21210 bool result;
21211 PyObject * obj0 = 0 ;
21212 char *kwnames[] = {
21213 (char *) "self", NULL
21214 };
21215
21216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
21217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21218 if (SWIG_arg_fail(1)) SWIG_fail;
21219 {
21220 PyThreadState* __tstate = wxPyBeginAllowThreads();
21221 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
21222
21223 wxPyEndAllowThreads(__tstate);
21224 if (PyErr_Occurred()) SWIG_fail;
21225 }
21226 {
21227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21228 }
21229 return resultobj;
21230 fail:
21231 return NULL;
21232 }
21233
21234
21235 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
21236 PyObject *obj;
21237 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21238 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
21239 Py_INCREF(obj);
21240 return Py_BuildValue((char *)"");
21241 }
21242 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21243 PyObject *resultobj = NULL;
21244 int arg1 = (int) 0 ;
21245 bool arg2 = (bool) false ;
21246 wxShowEvent *result;
21247 PyObject * obj0 = 0 ;
21248 PyObject * obj1 = 0 ;
21249 char *kwnames[] = {
21250 (char *) "winid",(char *) "show", NULL
21251 };
21252
21253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
21254 if (obj0) {
21255 {
21256 arg1 = static_cast<int >(SWIG_As_int(obj0));
21257 if (SWIG_arg_fail(1)) SWIG_fail;
21258 }
21259 }
21260 if (obj1) {
21261 {
21262 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21263 if (SWIG_arg_fail(2)) SWIG_fail;
21264 }
21265 }
21266 {
21267 PyThreadState* __tstate = wxPyBeginAllowThreads();
21268 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
21269
21270 wxPyEndAllowThreads(__tstate);
21271 if (PyErr_Occurred()) SWIG_fail;
21272 }
21273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
21274 return resultobj;
21275 fail:
21276 return NULL;
21277 }
21278
21279
21280 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21281 PyObject *resultobj = NULL;
21282 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21283 bool arg2 ;
21284 PyObject * obj0 = 0 ;
21285 PyObject * obj1 = 0 ;
21286 char *kwnames[] = {
21287 (char *) "self",(char *) "show", NULL
21288 };
21289
21290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
21291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21292 if (SWIG_arg_fail(1)) SWIG_fail;
21293 {
21294 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21295 if (SWIG_arg_fail(2)) SWIG_fail;
21296 }
21297 {
21298 PyThreadState* __tstate = wxPyBeginAllowThreads();
21299 (arg1)->SetShow(arg2);
21300
21301 wxPyEndAllowThreads(__tstate);
21302 if (PyErr_Occurred()) SWIG_fail;
21303 }
21304 Py_INCREF(Py_None); resultobj = Py_None;
21305 return resultobj;
21306 fail:
21307 return NULL;
21308 }
21309
21310
21311 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21312 PyObject *resultobj = NULL;
21313 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21314 bool result;
21315 PyObject * obj0 = 0 ;
21316 char *kwnames[] = {
21317 (char *) "self", NULL
21318 };
21319
21320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
21321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21322 if (SWIG_arg_fail(1)) SWIG_fail;
21323 {
21324 PyThreadState* __tstate = wxPyBeginAllowThreads();
21325 result = (bool)((wxShowEvent const *)arg1)->GetShow();
21326
21327 wxPyEndAllowThreads(__tstate);
21328 if (PyErr_Occurred()) SWIG_fail;
21329 }
21330 {
21331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21332 }
21333 return resultobj;
21334 fail:
21335 return NULL;
21336 }
21337
21338
21339 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
21340 PyObject *obj;
21341 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21342 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
21343 Py_INCREF(obj);
21344 return Py_BuildValue((char *)"");
21345 }
21346 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21347 PyObject *resultobj = NULL;
21348 int arg1 = (int) 0 ;
21349 bool arg2 = (bool) true ;
21350 wxIconizeEvent *result;
21351 PyObject * obj0 = 0 ;
21352 PyObject * obj1 = 0 ;
21353 char *kwnames[] = {
21354 (char *) "id",(char *) "iconized", NULL
21355 };
21356
21357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
21358 if (obj0) {
21359 {
21360 arg1 = static_cast<int >(SWIG_As_int(obj0));
21361 if (SWIG_arg_fail(1)) SWIG_fail;
21362 }
21363 }
21364 if (obj1) {
21365 {
21366 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21367 if (SWIG_arg_fail(2)) SWIG_fail;
21368 }
21369 }
21370 {
21371 PyThreadState* __tstate = wxPyBeginAllowThreads();
21372 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
21373
21374 wxPyEndAllowThreads(__tstate);
21375 if (PyErr_Occurred()) SWIG_fail;
21376 }
21377 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
21378 return resultobj;
21379 fail:
21380 return NULL;
21381 }
21382
21383
21384 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
21385 PyObject *resultobj = NULL;
21386 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
21387 bool result;
21388 PyObject * obj0 = 0 ;
21389 char *kwnames[] = {
21390 (char *) "self", NULL
21391 };
21392
21393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
21394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
21395 if (SWIG_arg_fail(1)) SWIG_fail;
21396 {
21397 PyThreadState* __tstate = wxPyBeginAllowThreads();
21398 result = (bool)(arg1)->Iconized();
21399
21400 wxPyEndAllowThreads(__tstate);
21401 if (PyErr_Occurred()) SWIG_fail;
21402 }
21403 {
21404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21405 }
21406 return resultobj;
21407 fail:
21408 return NULL;
21409 }
21410
21411
21412 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
21413 PyObject *obj;
21414 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21415 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
21416 Py_INCREF(obj);
21417 return Py_BuildValue((char *)"");
21418 }
21419 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21420 PyObject *resultobj = NULL;
21421 int arg1 = (int) 0 ;
21422 wxMaximizeEvent *result;
21423 PyObject * obj0 = 0 ;
21424 char *kwnames[] = {
21425 (char *) "id", NULL
21426 };
21427
21428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
21429 if (obj0) {
21430 {
21431 arg1 = static_cast<int >(SWIG_As_int(obj0));
21432 if (SWIG_arg_fail(1)) SWIG_fail;
21433 }
21434 }
21435 {
21436 PyThreadState* __tstate = wxPyBeginAllowThreads();
21437 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
21438
21439 wxPyEndAllowThreads(__tstate);
21440 if (PyErr_Occurred()) SWIG_fail;
21441 }
21442 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
21443 return resultobj;
21444 fail:
21445 return NULL;
21446 }
21447
21448
21449 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
21450 PyObject *obj;
21451 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21452 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
21453 Py_INCREF(obj);
21454 return Py_BuildValue((char *)"");
21455 }
21456 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21457 PyObject *resultobj = NULL;
21458 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21459 wxPoint result;
21460 PyObject * obj0 = 0 ;
21461 char *kwnames[] = {
21462 (char *) "self", NULL
21463 };
21464
21465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
21466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21467 if (SWIG_arg_fail(1)) SWIG_fail;
21468 {
21469 PyThreadState* __tstate = wxPyBeginAllowThreads();
21470 result = (arg1)->GetPosition();
21471
21472 wxPyEndAllowThreads(__tstate);
21473 if (PyErr_Occurred()) SWIG_fail;
21474 }
21475 {
21476 wxPoint * resultptr;
21477 resultptr = new wxPoint(static_cast<wxPoint & >(result));
21478 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
21479 }
21480 return resultobj;
21481 fail:
21482 return NULL;
21483 }
21484
21485
21486 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21487 PyObject *resultobj = NULL;
21488 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21489 int result;
21490 PyObject * obj0 = 0 ;
21491 char *kwnames[] = {
21492 (char *) "self", NULL
21493 };
21494
21495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
21496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21497 if (SWIG_arg_fail(1)) SWIG_fail;
21498 {
21499 PyThreadState* __tstate = wxPyBeginAllowThreads();
21500 result = (int)(arg1)->GetNumberOfFiles();
21501
21502 wxPyEndAllowThreads(__tstate);
21503 if (PyErr_Occurred()) SWIG_fail;
21504 }
21505 {
21506 resultobj = SWIG_From_int(static_cast<int >(result));
21507 }
21508 return resultobj;
21509 fail:
21510 return NULL;
21511 }
21512
21513
21514 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21515 PyObject *resultobj = NULL;
21516 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21517 PyObject *result;
21518 PyObject * obj0 = 0 ;
21519 char *kwnames[] = {
21520 (char *) "self", NULL
21521 };
21522
21523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
21524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21525 if (SWIG_arg_fail(1)) SWIG_fail;
21526 {
21527 PyThreadState* __tstate = wxPyBeginAllowThreads();
21528 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
21529
21530 wxPyEndAllowThreads(__tstate);
21531 if (PyErr_Occurred()) SWIG_fail;
21532 }
21533 resultobj = result;
21534 return resultobj;
21535 fail:
21536 return NULL;
21537 }
21538
21539
21540 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
21541 PyObject *obj;
21542 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21543 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
21544 Py_INCREF(obj);
21545 return Py_BuildValue((char *)"");
21546 }
21547 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21548 PyObject *resultobj = NULL;
21549 int arg1 = (int) 0 ;
21550 wxUpdateUIEvent *result;
21551 PyObject * obj0 = 0 ;
21552 char *kwnames[] = {
21553 (char *) "commandId", NULL
21554 };
21555
21556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
21557 if (obj0) {
21558 {
21559 arg1 = static_cast<int >(SWIG_As_int(obj0));
21560 if (SWIG_arg_fail(1)) SWIG_fail;
21561 }
21562 }
21563 {
21564 PyThreadState* __tstate = wxPyBeginAllowThreads();
21565 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
21566
21567 wxPyEndAllowThreads(__tstate);
21568 if (PyErr_Occurred()) SWIG_fail;
21569 }
21570 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
21571 return resultobj;
21572 fail:
21573 return NULL;
21574 }
21575
21576
21577 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21578 PyObject *resultobj = NULL;
21579 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21580 bool result;
21581 PyObject * obj0 = 0 ;
21582 char *kwnames[] = {
21583 (char *) "self", NULL
21584 };
21585
21586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
21587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21588 if (SWIG_arg_fail(1)) SWIG_fail;
21589 {
21590 PyThreadState* __tstate = wxPyBeginAllowThreads();
21591 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
21592
21593 wxPyEndAllowThreads(__tstate);
21594 if (PyErr_Occurred()) SWIG_fail;
21595 }
21596 {
21597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21598 }
21599 return resultobj;
21600 fail:
21601 return NULL;
21602 }
21603
21604
21605 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21606 PyObject *resultobj = NULL;
21607 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21608 bool result;
21609 PyObject * obj0 = 0 ;
21610 char *kwnames[] = {
21611 (char *) "self", NULL
21612 };
21613
21614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
21615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21616 if (SWIG_arg_fail(1)) SWIG_fail;
21617 {
21618 PyThreadState* __tstate = wxPyBeginAllowThreads();
21619 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
21620
21621 wxPyEndAllowThreads(__tstate);
21622 if (PyErr_Occurred()) SWIG_fail;
21623 }
21624 {
21625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21626 }
21627 return resultobj;
21628 fail:
21629 return NULL;
21630 }
21631
21632
21633 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
21634 PyObject *resultobj = NULL;
21635 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21636 wxString result;
21637 PyObject * obj0 = 0 ;
21638 char *kwnames[] = {
21639 (char *) "self", NULL
21640 };
21641
21642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
21643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21644 if (SWIG_arg_fail(1)) SWIG_fail;
21645 {
21646 PyThreadState* __tstate = wxPyBeginAllowThreads();
21647 result = ((wxUpdateUIEvent const *)arg1)->GetText();
21648
21649 wxPyEndAllowThreads(__tstate);
21650 if (PyErr_Occurred()) SWIG_fail;
21651 }
21652 {
21653 #if wxUSE_UNICODE
21654 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21655 #else
21656 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21657 #endif
21658 }
21659 return resultobj;
21660 fail:
21661 return NULL;
21662 }
21663
21664
21665 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
21666 PyObject *resultobj = NULL;
21667 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21668 bool result;
21669 PyObject * obj0 = 0 ;
21670 char *kwnames[] = {
21671 (char *) "self", NULL
21672 };
21673
21674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
21675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21676 if (SWIG_arg_fail(1)) SWIG_fail;
21677 {
21678 PyThreadState* __tstate = wxPyBeginAllowThreads();
21679 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
21680
21681 wxPyEndAllowThreads(__tstate);
21682 if (PyErr_Occurred()) SWIG_fail;
21683 }
21684 {
21685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21686 }
21687 return resultobj;
21688 fail:
21689 return NULL;
21690 }
21691
21692
21693 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21694 PyObject *resultobj = NULL;
21695 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21696 bool result;
21697 PyObject * obj0 = 0 ;
21698 char *kwnames[] = {
21699 (char *) "self", NULL
21700 };
21701
21702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
21703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21704 if (SWIG_arg_fail(1)) SWIG_fail;
21705 {
21706 PyThreadState* __tstate = wxPyBeginAllowThreads();
21707 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
21708
21709 wxPyEndAllowThreads(__tstate);
21710 if (PyErr_Occurred()) SWIG_fail;
21711 }
21712 {
21713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21714 }
21715 return resultobj;
21716 fail:
21717 return NULL;
21718 }
21719
21720
21721 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21722 PyObject *resultobj = NULL;
21723 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21724 bool result;
21725 PyObject * obj0 = 0 ;
21726 char *kwnames[] = {
21727 (char *) "self", NULL
21728 };
21729
21730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
21731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21732 if (SWIG_arg_fail(1)) SWIG_fail;
21733 {
21734 PyThreadState* __tstate = wxPyBeginAllowThreads();
21735 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
21736
21737 wxPyEndAllowThreads(__tstate);
21738 if (PyErr_Occurred()) SWIG_fail;
21739 }
21740 {
21741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21742 }
21743 return resultobj;
21744 fail:
21745 return NULL;
21746 }
21747
21748
21749 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
21750 PyObject *resultobj = NULL;
21751 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21752 bool arg2 ;
21753 PyObject * obj0 = 0 ;
21754 PyObject * obj1 = 0 ;
21755 char *kwnames[] = {
21756 (char *) "self",(char *) "check", NULL
21757 };
21758
21759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
21760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21761 if (SWIG_arg_fail(1)) SWIG_fail;
21762 {
21763 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21764 if (SWIG_arg_fail(2)) SWIG_fail;
21765 }
21766 {
21767 PyThreadState* __tstate = wxPyBeginAllowThreads();
21768 (arg1)->Check(arg2);
21769
21770 wxPyEndAllowThreads(__tstate);
21771 if (PyErr_Occurred()) SWIG_fail;
21772 }
21773 Py_INCREF(Py_None); resultobj = Py_None;
21774 return resultobj;
21775 fail:
21776 return NULL;
21777 }
21778
21779
21780 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21781 PyObject *resultobj = NULL;
21782 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21783 bool arg2 ;
21784 PyObject * obj0 = 0 ;
21785 PyObject * obj1 = 0 ;
21786 char *kwnames[] = {
21787 (char *) "self",(char *) "enable", NULL
21788 };
21789
21790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21792 if (SWIG_arg_fail(1)) SWIG_fail;
21793 {
21794 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21795 if (SWIG_arg_fail(2)) SWIG_fail;
21796 }
21797 {
21798 PyThreadState* __tstate = wxPyBeginAllowThreads();
21799 (arg1)->Enable(arg2);
21800
21801 wxPyEndAllowThreads(__tstate);
21802 if (PyErr_Occurred()) SWIG_fail;
21803 }
21804 Py_INCREF(Py_None); resultobj = Py_None;
21805 return resultobj;
21806 fail:
21807 return NULL;
21808 }
21809
21810
21811 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21812 PyObject *resultobj = NULL;
21813 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21814 wxString *arg2 = 0 ;
21815 bool temp2 = false ;
21816 PyObject * obj0 = 0 ;
21817 PyObject * obj1 = 0 ;
21818 char *kwnames[] = {
21819 (char *) "self",(char *) "text", NULL
21820 };
21821
21822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21824 if (SWIG_arg_fail(1)) SWIG_fail;
21825 {
21826 arg2 = wxString_in_helper(obj1);
21827 if (arg2 == NULL) SWIG_fail;
21828 temp2 = true;
21829 }
21830 {
21831 PyThreadState* __tstate = wxPyBeginAllowThreads();
21832 (arg1)->SetText((wxString const &)*arg2);
21833
21834 wxPyEndAllowThreads(__tstate);
21835 if (PyErr_Occurred()) SWIG_fail;
21836 }
21837 Py_INCREF(Py_None); resultobj = Py_None;
21838 {
21839 if (temp2)
21840 delete arg2;
21841 }
21842 return resultobj;
21843 fail:
21844 {
21845 if (temp2)
21846 delete arg2;
21847 }
21848 return NULL;
21849 }
21850
21851
21852 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21853 PyObject *resultobj = NULL;
21854 long arg1 ;
21855 PyObject * obj0 = 0 ;
21856 char *kwnames[] = {
21857 (char *) "updateInterval", NULL
21858 };
21859
21860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21861 {
21862 arg1 = static_cast<long >(SWIG_As_long(obj0));
21863 if (SWIG_arg_fail(1)) SWIG_fail;
21864 }
21865 {
21866 PyThreadState* __tstate = wxPyBeginAllowThreads();
21867 wxUpdateUIEvent::SetUpdateInterval(arg1);
21868
21869 wxPyEndAllowThreads(__tstate);
21870 if (PyErr_Occurred()) SWIG_fail;
21871 }
21872 Py_INCREF(Py_None); resultobj = Py_None;
21873 return resultobj;
21874 fail:
21875 return NULL;
21876 }
21877
21878
21879 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21880 PyObject *resultobj = NULL;
21881 long result;
21882 char *kwnames[] = {
21883 NULL
21884 };
21885
21886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21887 {
21888 PyThreadState* __tstate = wxPyBeginAllowThreads();
21889 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21890
21891 wxPyEndAllowThreads(__tstate);
21892 if (PyErr_Occurred()) SWIG_fail;
21893 }
21894 {
21895 resultobj = SWIG_From_long(static_cast<long >(result));
21896 }
21897 return resultobj;
21898 fail:
21899 return NULL;
21900 }
21901
21902
21903 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21904 PyObject *resultobj = NULL;
21905 wxWindow *arg1 = (wxWindow *) 0 ;
21906 bool result;
21907 PyObject * obj0 = 0 ;
21908 char *kwnames[] = {
21909 (char *) "win", NULL
21910 };
21911
21912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21914 if (SWIG_arg_fail(1)) SWIG_fail;
21915 {
21916 PyThreadState* __tstate = wxPyBeginAllowThreads();
21917 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21918
21919 wxPyEndAllowThreads(__tstate);
21920 if (PyErr_Occurred()) SWIG_fail;
21921 }
21922 {
21923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21924 }
21925 return resultobj;
21926 fail:
21927 return NULL;
21928 }
21929
21930
21931 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21932 PyObject *resultobj = NULL;
21933 char *kwnames[] = {
21934 NULL
21935 };
21936
21937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21938 {
21939 PyThreadState* __tstate = wxPyBeginAllowThreads();
21940 wxUpdateUIEvent::ResetUpdateTime();
21941
21942 wxPyEndAllowThreads(__tstate);
21943 if (PyErr_Occurred()) SWIG_fail;
21944 }
21945 Py_INCREF(Py_None); resultobj = Py_None;
21946 return resultobj;
21947 fail:
21948 return NULL;
21949 }
21950
21951
21952 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21953 PyObject *resultobj = NULL;
21954 wxUpdateUIMode arg1 ;
21955 PyObject * obj0 = 0 ;
21956 char *kwnames[] = {
21957 (char *) "mode", NULL
21958 };
21959
21960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21961 {
21962 arg1 = static_cast<wxUpdateUIMode >(SWIG_As_int(obj0));
21963 if (SWIG_arg_fail(1)) SWIG_fail;
21964 }
21965 {
21966 PyThreadState* __tstate = wxPyBeginAllowThreads();
21967 wxUpdateUIEvent::SetMode(arg1);
21968
21969 wxPyEndAllowThreads(__tstate);
21970 if (PyErr_Occurred()) SWIG_fail;
21971 }
21972 Py_INCREF(Py_None); resultobj = Py_None;
21973 return resultobj;
21974 fail:
21975 return NULL;
21976 }
21977
21978
21979 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21980 PyObject *resultobj = NULL;
21981 wxUpdateUIMode result;
21982 char *kwnames[] = {
21983 NULL
21984 };
21985
21986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21987 {
21988 PyThreadState* __tstate = wxPyBeginAllowThreads();
21989 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21990
21991 wxPyEndAllowThreads(__tstate);
21992 if (PyErr_Occurred()) SWIG_fail;
21993 }
21994 resultobj = SWIG_From_int((result));
21995 return resultobj;
21996 fail:
21997 return NULL;
21998 }
21999
22000
22001 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
22002 PyObject *obj;
22003 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22004 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
22005 Py_INCREF(obj);
22006 return Py_BuildValue((char *)"");
22007 }
22008 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22009 PyObject *resultobj = NULL;
22010 wxSysColourChangedEvent *result;
22011 char *kwnames[] = {
22012 NULL
22013 };
22014
22015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
22016 {
22017 PyThreadState* __tstate = wxPyBeginAllowThreads();
22018 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
22019
22020 wxPyEndAllowThreads(__tstate);
22021 if (PyErr_Occurred()) SWIG_fail;
22022 }
22023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
22024 return resultobj;
22025 fail:
22026 return NULL;
22027 }
22028
22029
22030 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
22031 PyObject *obj;
22032 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22033 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
22034 Py_INCREF(obj);
22035 return Py_BuildValue((char *)"");
22036 }
22037 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22038 PyObject *resultobj = NULL;
22039 int arg1 = (int) 0 ;
22040 wxWindow *arg2 = (wxWindow *) NULL ;
22041 wxMouseCaptureChangedEvent *result;
22042 PyObject * obj0 = 0 ;
22043 PyObject * obj1 = 0 ;
22044 char *kwnames[] = {
22045 (char *) "winid",(char *) "gainedCapture", NULL
22046 };
22047
22048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
22049 if (obj0) {
22050 {
22051 arg1 = static_cast<int >(SWIG_As_int(obj0));
22052 if (SWIG_arg_fail(1)) SWIG_fail;
22053 }
22054 }
22055 if (obj1) {
22056 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22057 if (SWIG_arg_fail(2)) SWIG_fail;
22058 }
22059 {
22060 PyThreadState* __tstate = wxPyBeginAllowThreads();
22061 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
22062
22063 wxPyEndAllowThreads(__tstate);
22064 if (PyErr_Occurred()) SWIG_fail;
22065 }
22066 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
22067 return resultobj;
22068 fail:
22069 return NULL;
22070 }
22071
22072
22073 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22074 PyObject *resultobj = NULL;
22075 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
22076 wxWindow *result;
22077 PyObject * obj0 = 0 ;
22078 char *kwnames[] = {
22079 (char *) "self", NULL
22080 };
22081
22082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
22083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22084 if (SWIG_arg_fail(1)) SWIG_fail;
22085 {
22086 PyThreadState* __tstate = wxPyBeginAllowThreads();
22087 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
22088
22089 wxPyEndAllowThreads(__tstate);
22090 if (PyErr_Occurred()) SWIG_fail;
22091 }
22092 {
22093 resultobj = wxPyMake_wxObject(result, 0);
22094 }
22095 return resultobj;
22096 fail:
22097 return NULL;
22098 }
22099
22100
22101 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
22102 PyObject *obj;
22103 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22104 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
22105 Py_INCREF(obj);
22106 return Py_BuildValue((char *)"");
22107 }
22108 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22109 PyObject *resultobj = NULL;
22110 wxDisplayChangedEvent *result;
22111 char *kwnames[] = {
22112 NULL
22113 };
22114
22115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
22116 {
22117 PyThreadState* __tstate = wxPyBeginAllowThreads();
22118 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
22119
22120 wxPyEndAllowThreads(__tstate);
22121 if (PyErr_Occurred()) SWIG_fail;
22122 }
22123 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
22124 return resultobj;
22125 fail:
22126 return NULL;
22127 }
22128
22129
22130 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
22131 PyObject *obj;
22132 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22133 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
22134 Py_INCREF(obj);
22135 return Py_BuildValue((char *)"");
22136 }
22137 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22138 PyObject *resultobj = NULL;
22139 int arg1 = (int) 0 ;
22140 wxPaletteChangedEvent *result;
22141 PyObject * obj0 = 0 ;
22142 char *kwnames[] = {
22143 (char *) "id", NULL
22144 };
22145
22146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
22147 if (obj0) {
22148 {
22149 arg1 = static_cast<int >(SWIG_As_int(obj0));
22150 if (SWIG_arg_fail(1)) SWIG_fail;
22151 }
22152 }
22153 {
22154 PyThreadState* __tstate = wxPyBeginAllowThreads();
22155 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
22156
22157 wxPyEndAllowThreads(__tstate);
22158 if (PyErr_Occurred()) SWIG_fail;
22159 }
22160 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
22161 return resultobj;
22162 fail:
22163 return NULL;
22164 }
22165
22166
22167 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22168 PyObject *resultobj = NULL;
22169 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22170 wxWindow *arg2 = (wxWindow *) 0 ;
22171 PyObject * obj0 = 0 ;
22172 PyObject * obj1 = 0 ;
22173 char *kwnames[] = {
22174 (char *) "self",(char *) "win", NULL
22175 };
22176
22177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
22178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22179 if (SWIG_arg_fail(1)) SWIG_fail;
22180 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22181 if (SWIG_arg_fail(2)) SWIG_fail;
22182 {
22183 PyThreadState* __tstate = wxPyBeginAllowThreads();
22184 (arg1)->SetChangedWindow(arg2);
22185
22186 wxPyEndAllowThreads(__tstate);
22187 if (PyErr_Occurred()) SWIG_fail;
22188 }
22189 Py_INCREF(Py_None); resultobj = Py_None;
22190 return resultobj;
22191 fail:
22192 return NULL;
22193 }
22194
22195
22196 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22197 PyObject *resultobj = NULL;
22198 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22199 wxWindow *result;
22200 PyObject * obj0 = 0 ;
22201 char *kwnames[] = {
22202 (char *) "self", NULL
22203 };
22204
22205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
22206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22207 if (SWIG_arg_fail(1)) SWIG_fail;
22208 {
22209 PyThreadState* __tstate = wxPyBeginAllowThreads();
22210 result = (wxWindow *)(arg1)->GetChangedWindow();
22211
22212 wxPyEndAllowThreads(__tstate);
22213 if (PyErr_Occurred()) SWIG_fail;
22214 }
22215 {
22216 resultobj = wxPyMake_wxObject(result, 0);
22217 }
22218 return resultobj;
22219 fail:
22220 return NULL;
22221 }
22222
22223
22224 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
22225 PyObject *obj;
22226 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22227 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
22228 Py_INCREF(obj);
22229 return Py_BuildValue((char *)"");
22230 }
22231 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22232 PyObject *resultobj = NULL;
22233 int arg1 = (int) 0 ;
22234 wxQueryNewPaletteEvent *result;
22235 PyObject * obj0 = 0 ;
22236 char *kwnames[] = {
22237 (char *) "winid", NULL
22238 };
22239
22240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
22241 if (obj0) {
22242 {
22243 arg1 = static_cast<int >(SWIG_As_int(obj0));
22244 if (SWIG_arg_fail(1)) SWIG_fail;
22245 }
22246 }
22247 {
22248 PyThreadState* __tstate = wxPyBeginAllowThreads();
22249 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
22250
22251 wxPyEndAllowThreads(__tstate);
22252 if (PyErr_Occurred()) SWIG_fail;
22253 }
22254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
22255 return resultobj;
22256 fail:
22257 return NULL;
22258 }
22259
22260
22261 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22262 PyObject *resultobj = NULL;
22263 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22264 bool arg2 ;
22265 PyObject * obj0 = 0 ;
22266 PyObject * obj1 = 0 ;
22267 char *kwnames[] = {
22268 (char *) "self",(char *) "realized", NULL
22269 };
22270
22271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
22272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22273 if (SWIG_arg_fail(1)) SWIG_fail;
22274 {
22275 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22276 if (SWIG_arg_fail(2)) SWIG_fail;
22277 }
22278 {
22279 PyThreadState* __tstate = wxPyBeginAllowThreads();
22280 (arg1)->SetPaletteRealized(arg2);
22281
22282 wxPyEndAllowThreads(__tstate);
22283 if (PyErr_Occurred()) SWIG_fail;
22284 }
22285 Py_INCREF(Py_None); resultobj = Py_None;
22286 return resultobj;
22287 fail:
22288 return NULL;
22289 }
22290
22291
22292 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22293 PyObject *resultobj = NULL;
22294 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22295 bool result;
22296 PyObject * obj0 = 0 ;
22297 char *kwnames[] = {
22298 (char *) "self", NULL
22299 };
22300
22301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
22302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22303 if (SWIG_arg_fail(1)) SWIG_fail;
22304 {
22305 PyThreadState* __tstate = wxPyBeginAllowThreads();
22306 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
22307
22308 wxPyEndAllowThreads(__tstate);
22309 if (PyErr_Occurred()) SWIG_fail;
22310 }
22311 {
22312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22313 }
22314 return resultobj;
22315 fail:
22316 return NULL;
22317 }
22318
22319
22320 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
22321 PyObject *obj;
22322 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22323 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
22324 Py_INCREF(obj);
22325 return Py_BuildValue((char *)"");
22326 }
22327 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22328 PyObject *resultobj = NULL;
22329 wxNavigationKeyEvent *result;
22330 char *kwnames[] = {
22331 NULL
22332 };
22333
22334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
22335 {
22336 PyThreadState* __tstate = wxPyBeginAllowThreads();
22337 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
22338
22339 wxPyEndAllowThreads(__tstate);
22340 if (PyErr_Occurred()) SWIG_fail;
22341 }
22342 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
22343 return resultobj;
22344 fail:
22345 return NULL;
22346 }
22347
22348
22349 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22350 PyObject *resultobj = NULL;
22351 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22352 bool result;
22353 PyObject * obj0 = 0 ;
22354 char *kwnames[] = {
22355 (char *) "self", NULL
22356 };
22357
22358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
22359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22360 if (SWIG_arg_fail(1)) SWIG_fail;
22361 {
22362 PyThreadState* __tstate = wxPyBeginAllowThreads();
22363 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
22364
22365 wxPyEndAllowThreads(__tstate);
22366 if (PyErr_Occurred()) SWIG_fail;
22367 }
22368 {
22369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22370 }
22371 return resultobj;
22372 fail:
22373 return NULL;
22374 }
22375
22376
22377 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22378 PyObject *resultobj = NULL;
22379 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22380 bool arg2 ;
22381 PyObject * obj0 = 0 ;
22382 PyObject * obj1 = 0 ;
22383 char *kwnames[] = {
22384 (char *) "self",(char *) "forward", NULL
22385 };
22386
22387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
22388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22389 if (SWIG_arg_fail(1)) SWIG_fail;
22390 {
22391 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22392 if (SWIG_arg_fail(2)) SWIG_fail;
22393 }
22394 {
22395 PyThreadState* __tstate = wxPyBeginAllowThreads();
22396 (arg1)->SetDirection(arg2);
22397
22398 wxPyEndAllowThreads(__tstate);
22399 if (PyErr_Occurred()) SWIG_fail;
22400 }
22401 Py_INCREF(Py_None); resultobj = Py_None;
22402 return resultobj;
22403 fail:
22404 return NULL;
22405 }
22406
22407
22408 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22409 PyObject *resultobj = NULL;
22410 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22411 bool result;
22412 PyObject * obj0 = 0 ;
22413 char *kwnames[] = {
22414 (char *) "self", NULL
22415 };
22416
22417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
22418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22419 if (SWIG_arg_fail(1)) SWIG_fail;
22420 {
22421 PyThreadState* __tstate = wxPyBeginAllowThreads();
22422 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
22423
22424 wxPyEndAllowThreads(__tstate);
22425 if (PyErr_Occurred()) SWIG_fail;
22426 }
22427 {
22428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22429 }
22430 return resultobj;
22431 fail:
22432 return NULL;
22433 }
22434
22435
22436 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22437 PyObject *resultobj = NULL;
22438 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22439 bool arg2 ;
22440 PyObject * obj0 = 0 ;
22441 PyObject * obj1 = 0 ;
22442 char *kwnames[] = {
22443 (char *) "self",(char *) "ischange", NULL
22444 };
22445
22446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
22447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22448 if (SWIG_arg_fail(1)) SWIG_fail;
22449 {
22450 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22451 if (SWIG_arg_fail(2)) SWIG_fail;
22452 }
22453 {
22454 PyThreadState* __tstate = wxPyBeginAllowThreads();
22455 (arg1)->SetWindowChange(arg2);
22456
22457 wxPyEndAllowThreads(__tstate);
22458 if (PyErr_Occurred()) SWIG_fail;
22459 }
22460 Py_INCREF(Py_None); resultobj = Py_None;
22461 return resultobj;
22462 fail:
22463 return NULL;
22464 }
22465
22466
22467 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22468 PyObject *resultobj = NULL;
22469 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22470 bool result;
22471 PyObject * obj0 = 0 ;
22472 char *kwnames[] = {
22473 (char *) "self", NULL
22474 };
22475
22476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
22477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22478 if (SWIG_arg_fail(1)) SWIG_fail;
22479 {
22480 PyThreadState* __tstate = wxPyBeginAllowThreads();
22481 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
22482
22483 wxPyEndAllowThreads(__tstate);
22484 if (PyErr_Occurred()) SWIG_fail;
22485 }
22486 {
22487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22488 }
22489 return resultobj;
22490 fail:
22491 return NULL;
22492 }
22493
22494
22495 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22496 PyObject *resultobj = NULL;
22497 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22498 bool arg2 ;
22499 PyObject * obj0 = 0 ;
22500 PyObject * obj1 = 0 ;
22501 char *kwnames[] = {
22502 (char *) "self",(char *) "bIs", NULL
22503 };
22504
22505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
22506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22507 if (SWIG_arg_fail(1)) SWIG_fail;
22508 {
22509 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22510 if (SWIG_arg_fail(2)) SWIG_fail;
22511 }
22512 {
22513 PyThreadState* __tstate = wxPyBeginAllowThreads();
22514 (arg1)->SetFromTab(arg2);
22515
22516 wxPyEndAllowThreads(__tstate);
22517 if (PyErr_Occurred()) SWIG_fail;
22518 }
22519 Py_INCREF(Py_None); resultobj = Py_None;
22520 return resultobj;
22521 fail:
22522 return NULL;
22523 }
22524
22525
22526 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
22527 PyObject *resultobj = NULL;
22528 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22529 long arg2 ;
22530 PyObject * obj0 = 0 ;
22531 PyObject * obj1 = 0 ;
22532 char *kwnames[] = {
22533 (char *) "self",(char *) "flags", NULL
22534 };
22535
22536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
22537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22538 if (SWIG_arg_fail(1)) SWIG_fail;
22539 {
22540 arg2 = static_cast<long >(SWIG_As_long(obj1));
22541 if (SWIG_arg_fail(2)) SWIG_fail;
22542 }
22543 {
22544 PyThreadState* __tstate = wxPyBeginAllowThreads();
22545 (arg1)->SetFlags(arg2);
22546
22547 wxPyEndAllowThreads(__tstate);
22548 if (PyErr_Occurred()) SWIG_fail;
22549 }
22550 Py_INCREF(Py_None); resultobj = Py_None;
22551 return resultobj;
22552 fail:
22553 return NULL;
22554 }
22555
22556
22557 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22558 PyObject *resultobj = NULL;
22559 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22560 wxWindow *result;
22561 PyObject * obj0 = 0 ;
22562 char *kwnames[] = {
22563 (char *) "self", NULL
22564 };
22565
22566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
22567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22568 if (SWIG_arg_fail(1)) SWIG_fail;
22569 {
22570 PyThreadState* __tstate = wxPyBeginAllowThreads();
22571 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
22572
22573 wxPyEndAllowThreads(__tstate);
22574 if (PyErr_Occurred()) SWIG_fail;
22575 }
22576 {
22577 resultobj = wxPyMake_wxObject(result, 0);
22578 }
22579 return resultobj;
22580 fail:
22581 return NULL;
22582 }
22583
22584
22585 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22586 PyObject *resultobj = NULL;
22587 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22588 wxWindow *arg2 = (wxWindow *) 0 ;
22589 PyObject * obj0 = 0 ;
22590 PyObject * obj1 = 0 ;
22591 char *kwnames[] = {
22592 (char *) "self",(char *) "win", NULL
22593 };
22594
22595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
22596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22597 if (SWIG_arg_fail(1)) SWIG_fail;
22598 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22599 if (SWIG_arg_fail(2)) SWIG_fail;
22600 {
22601 PyThreadState* __tstate = wxPyBeginAllowThreads();
22602 (arg1)->SetCurrentFocus(arg2);
22603
22604 wxPyEndAllowThreads(__tstate);
22605 if (PyErr_Occurred()) SWIG_fail;
22606 }
22607 Py_INCREF(Py_None); resultobj = Py_None;
22608 return resultobj;
22609 fail:
22610 return NULL;
22611 }
22612
22613
22614 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
22615 PyObject *obj;
22616 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22617 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
22618 Py_INCREF(obj);
22619 return Py_BuildValue((char *)"");
22620 }
22621 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22622 PyObject *resultobj = NULL;
22623 wxWindow *arg1 = (wxWindow *) NULL ;
22624 wxWindowCreateEvent *result;
22625 PyObject * obj0 = 0 ;
22626 char *kwnames[] = {
22627 (char *) "win", NULL
22628 };
22629
22630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
22631 if (obj0) {
22632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22633 if (SWIG_arg_fail(1)) SWIG_fail;
22634 }
22635 {
22636 PyThreadState* __tstate = wxPyBeginAllowThreads();
22637 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
22638
22639 wxPyEndAllowThreads(__tstate);
22640 if (PyErr_Occurred()) SWIG_fail;
22641 }
22642 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
22643 return resultobj;
22644 fail:
22645 return NULL;
22646 }
22647
22648
22649 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22650 PyObject *resultobj = NULL;
22651 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
22652 wxWindow *result;
22653 PyObject * obj0 = 0 ;
22654 char *kwnames[] = {
22655 (char *) "self", NULL
22656 };
22657
22658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
22659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
22660 if (SWIG_arg_fail(1)) SWIG_fail;
22661 {
22662 PyThreadState* __tstate = wxPyBeginAllowThreads();
22663 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
22664
22665 wxPyEndAllowThreads(__tstate);
22666 if (PyErr_Occurred()) SWIG_fail;
22667 }
22668 {
22669 resultobj = wxPyMake_wxObject(result, 0);
22670 }
22671 return resultobj;
22672 fail:
22673 return NULL;
22674 }
22675
22676
22677 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
22678 PyObject *obj;
22679 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22680 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
22681 Py_INCREF(obj);
22682 return Py_BuildValue((char *)"");
22683 }
22684 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22685 PyObject *resultobj = NULL;
22686 wxWindow *arg1 = (wxWindow *) NULL ;
22687 wxWindowDestroyEvent *result;
22688 PyObject * obj0 = 0 ;
22689 char *kwnames[] = {
22690 (char *) "win", NULL
22691 };
22692
22693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
22694 if (obj0) {
22695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22696 if (SWIG_arg_fail(1)) SWIG_fail;
22697 }
22698 {
22699 PyThreadState* __tstate = wxPyBeginAllowThreads();
22700 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
22701
22702 wxPyEndAllowThreads(__tstate);
22703 if (PyErr_Occurred()) SWIG_fail;
22704 }
22705 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
22706 return resultobj;
22707 fail:
22708 return NULL;
22709 }
22710
22711
22712 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22713 PyObject *resultobj = NULL;
22714 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
22715 wxWindow *result;
22716 PyObject * obj0 = 0 ;
22717 char *kwnames[] = {
22718 (char *) "self", NULL
22719 };
22720
22721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
22722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
22723 if (SWIG_arg_fail(1)) SWIG_fail;
22724 {
22725 PyThreadState* __tstate = wxPyBeginAllowThreads();
22726 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
22727
22728 wxPyEndAllowThreads(__tstate);
22729 if (PyErr_Occurred()) SWIG_fail;
22730 }
22731 {
22732 resultobj = wxPyMake_wxObject(result, 0);
22733 }
22734 return resultobj;
22735 fail:
22736 return NULL;
22737 }
22738
22739
22740 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
22741 PyObject *obj;
22742 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22743 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
22744 Py_INCREF(obj);
22745 return Py_BuildValue((char *)"");
22746 }
22747 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22748 PyObject *resultobj = NULL;
22749 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22750 int arg2 = (int) 0 ;
22751 wxPoint const &arg3_defvalue = wxDefaultPosition ;
22752 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
22753 wxContextMenuEvent *result;
22754 wxPoint temp3 ;
22755 PyObject * obj0 = 0 ;
22756 PyObject * obj1 = 0 ;
22757 PyObject * obj2 = 0 ;
22758 char *kwnames[] = {
22759 (char *) "type",(char *) "winid",(char *) "pt", NULL
22760 };
22761
22762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22763 if (obj0) {
22764 {
22765 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
22766 if (SWIG_arg_fail(1)) SWIG_fail;
22767 }
22768 }
22769 if (obj1) {
22770 {
22771 arg2 = static_cast<int >(SWIG_As_int(obj1));
22772 if (SWIG_arg_fail(2)) SWIG_fail;
22773 }
22774 }
22775 if (obj2) {
22776 {
22777 arg3 = &temp3;
22778 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22779 }
22780 }
22781 {
22782 PyThreadState* __tstate = wxPyBeginAllowThreads();
22783 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22784
22785 wxPyEndAllowThreads(__tstate);
22786 if (PyErr_Occurred()) SWIG_fail;
22787 }
22788 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22789 return resultobj;
22790 fail:
22791 return NULL;
22792 }
22793
22794
22795 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22796 PyObject *resultobj = NULL;
22797 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22798 wxPoint *result;
22799 PyObject * obj0 = 0 ;
22800 char *kwnames[] = {
22801 (char *) "self", NULL
22802 };
22803
22804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22806 if (SWIG_arg_fail(1)) SWIG_fail;
22807 {
22808 PyThreadState* __tstate = wxPyBeginAllowThreads();
22809 {
22810 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22811 result = (wxPoint *) &_result_ref;
22812 }
22813
22814 wxPyEndAllowThreads(__tstate);
22815 if (PyErr_Occurred()) SWIG_fail;
22816 }
22817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22818 return resultobj;
22819 fail:
22820 return NULL;
22821 }
22822
22823
22824 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22825 PyObject *resultobj = NULL;
22826 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22827 wxPoint *arg2 = 0 ;
22828 wxPoint temp2 ;
22829 PyObject * obj0 = 0 ;
22830 PyObject * obj1 = 0 ;
22831 char *kwnames[] = {
22832 (char *) "self",(char *) "pos", NULL
22833 };
22834
22835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22837 if (SWIG_arg_fail(1)) SWIG_fail;
22838 {
22839 arg2 = &temp2;
22840 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22841 }
22842 {
22843 PyThreadState* __tstate = wxPyBeginAllowThreads();
22844 (arg1)->SetPosition((wxPoint const &)*arg2);
22845
22846 wxPyEndAllowThreads(__tstate);
22847 if (PyErr_Occurred()) SWIG_fail;
22848 }
22849 Py_INCREF(Py_None); resultobj = Py_None;
22850 return resultobj;
22851 fail:
22852 return NULL;
22853 }
22854
22855
22856 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22857 PyObject *obj;
22858 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22859 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22860 Py_INCREF(obj);
22861 return Py_BuildValue((char *)"");
22862 }
22863 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22864 PyObject *resultobj = NULL;
22865 wxIdleEvent *result;
22866 char *kwnames[] = {
22867 NULL
22868 };
22869
22870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22871 {
22872 PyThreadState* __tstate = wxPyBeginAllowThreads();
22873 result = (wxIdleEvent *)new wxIdleEvent();
22874
22875 wxPyEndAllowThreads(__tstate);
22876 if (PyErr_Occurred()) SWIG_fail;
22877 }
22878 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22879 return resultobj;
22880 fail:
22881 return NULL;
22882 }
22883
22884
22885 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22886 PyObject *resultobj = NULL;
22887 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22888 bool arg2 = (bool) true ;
22889 PyObject * obj0 = 0 ;
22890 PyObject * obj1 = 0 ;
22891 char *kwnames[] = {
22892 (char *) "self",(char *) "needMore", NULL
22893 };
22894
22895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22897 if (SWIG_arg_fail(1)) SWIG_fail;
22898 if (obj1) {
22899 {
22900 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22901 if (SWIG_arg_fail(2)) SWIG_fail;
22902 }
22903 }
22904 {
22905 PyThreadState* __tstate = wxPyBeginAllowThreads();
22906 (arg1)->RequestMore(arg2);
22907
22908 wxPyEndAllowThreads(__tstate);
22909 if (PyErr_Occurred()) SWIG_fail;
22910 }
22911 Py_INCREF(Py_None); resultobj = Py_None;
22912 return resultobj;
22913 fail:
22914 return NULL;
22915 }
22916
22917
22918 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22919 PyObject *resultobj = NULL;
22920 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22921 bool result;
22922 PyObject * obj0 = 0 ;
22923 char *kwnames[] = {
22924 (char *) "self", NULL
22925 };
22926
22927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22929 if (SWIG_arg_fail(1)) SWIG_fail;
22930 {
22931 PyThreadState* __tstate = wxPyBeginAllowThreads();
22932 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22933
22934 wxPyEndAllowThreads(__tstate);
22935 if (PyErr_Occurred()) SWIG_fail;
22936 }
22937 {
22938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22939 }
22940 return resultobj;
22941 fail:
22942 return NULL;
22943 }
22944
22945
22946 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22947 PyObject *resultobj = NULL;
22948 wxIdleMode arg1 ;
22949 PyObject * obj0 = 0 ;
22950 char *kwnames[] = {
22951 (char *) "mode", NULL
22952 };
22953
22954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22955 {
22956 arg1 = static_cast<wxIdleMode >(SWIG_As_int(obj0));
22957 if (SWIG_arg_fail(1)) SWIG_fail;
22958 }
22959 {
22960 PyThreadState* __tstate = wxPyBeginAllowThreads();
22961 wxIdleEvent::SetMode(arg1);
22962
22963 wxPyEndAllowThreads(__tstate);
22964 if (PyErr_Occurred()) SWIG_fail;
22965 }
22966 Py_INCREF(Py_None); resultobj = Py_None;
22967 return resultobj;
22968 fail:
22969 return NULL;
22970 }
22971
22972
22973 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22974 PyObject *resultobj = NULL;
22975 wxIdleMode result;
22976 char *kwnames[] = {
22977 NULL
22978 };
22979
22980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22981 {
22982 PyThreadState* __tstate = wxPyBeginAllowThreads();
22983 result = (wxIdleMode)wxIdleEvent::GetMode();
22984
22985 wxPyEndAllowThreads(__tstate);
22986 if (PyErr_Occurred()) SWIG_fail;
22987 }
22988 resultobj = SWIG_From_int((result));
22989 return resultobj;
22990 fail:
22991 return NULL;
22992 }
22993
22994
22995 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22996 PyObject *resultobj = NULL;
22997 wxWindow *arg1 = (wxWindow *) 0 ;
22998 bool result;
22999 PyObject * obj0 = 0 ;
23000 char *kwnames[] = {
23001 (char *) "win", NULL
23002 };
23003
23004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
23005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23006 if (SWIG_arg_fail(1)) SWIG_fail;
23007 {
23008 PyThreadState* __tstate = wxPyBeginAllowThreads();
23009 result = (bool)wxIdleEvent::CanSend(arg1);
23010
23011 wxPyEndAllowThreads(__tstate);
23012 if (PyErr_Occurred()) SWIG_fail;
23013 }
23014 {
23015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23016 }
23017 return resultobj;
23018 fail:
23019 return NULL;
23020 }
23021
23022
23023 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
23024 PyObject *obj;
23025 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23026 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
23027 Py_INCREF(obj);
23028 return Py_BuildValue((char *)"");
23029 }
23030 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23031 PyObject *resultobj = NULL;
23032 int arg1 = (int) 0 ;
23033 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
23034 wxPyEvent *result;
23035 PyObject * obj0 = 0 ;
23036 PyObject * obj1 = 0 ;
23037 char *kwnames[] = {
23038 (char *) "winid",(char *) "eventType", NULL
23039 };
23040
23041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
23042 if (obj0) {
23043 {
23044 arg1 = static_cast<int >(SWIG_As_int(obj0));
23045 if (SWIG_arg_fail(1)) SWIG_fail;
23046 }
23047 }
23048 if (obj1) {
23049 {
23050 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
23051 if (SWIG_arg_fail(2)) SWIG_fail;
23052 }
23053 }
23054 {
23055 PyThreadState* __tstate = wxPyBeginAllowThreads();
23056 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
23057
23058 wxPyEndAllowThreads(__tstate);
23059 if (PyErr_Occurred()) SWIG_fail;
23060 }
23061 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
23062 return resultobj;
23063 fail:
23064 return NULL;
23065 }
23066
23067
23068 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23069 PyObject *resultobj = NULL;
23070 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23071 PyObject * obj0 = 0 ;
23072 char *kwnames[] = {
23073 (char *) "self", NULL
23074 };
23075
23076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
23077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23078 if (SWIG_arg_fail(1)) SWIG_fail;
23079 {
23080 PyThreadState* __tstate = wxPyBeginAllowThreads();
23081 delete arg1;
23082
23083 wxPyEndAllowThreads(__tstate);
23084 if (PyErr_Occurred()) SWIG_fail;
23085 }
23086 Py_INCREF(Py_None); resultobj = Py_None;
23087 return resultobj;
23088 fail:
23089 return NULL;
23090 }
23091
23092
23093 static PyObject *_wrap_PyEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23094 PyObject *resultobj = NULL;
23095 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23096 PyObject *arg2 = (PyObject *) 0 ;
23097 PyObject * obj0 = 0 ;
23098 PyObject * obj1 = 0 ;
23099 char *kwnames[] = {
23100 (char *) "self",(char *) "self", NULL
23101 };
23102
23103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23105 if (SWIG_arg_fail(1)) SWIG_fail;
23106 arg2 = obj1;
23107 {
23108 PyThreadState* __tstate = wxPyBeginAllowThreads();
23109 (arg1)->SetSelf(arg2);
23110
23111 wxPyEndAllowThreads(__tstate);
23112 if (PyErr_Occurred()) SWIG_fail;
23113 }
23114 Py_INCREF(Py_None); resultobj = Py_None;
23115 return resultobj;
23116 fail:
23117 return NULL;
23118 }
23119
23120
23121 static PyObject *_wrap_PyEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23122 PyObject *resultobj = NULL;
23123 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23124 PyObject *result;
23125 PyObject * obj0 = 0 ;
23126 char *kwnames[] = {
23127 (char *) "self", NULL
23128 };
23129
23130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent__GetSelf",kwnames,&obj0)) goto fail;
23131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23132 if (SWIG_arg_fail(1)) SWIG_fail;
23133 {
23134 PyThreadState* __tstate = wxPyBeginAllowThreads();
23135 result = (PyObject *)(arg1)->GetSelf();
23136
23137 wxPyEndAllowThreads(__tstate);
23138 if (PyErr_Occurred()) SWIG_fail;
23139 }
23140 resultobj = result;
23141 return resultobj;
23142 fail:
23143 return NULL;
23144 }
23145
23146
23147 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
23148 PyObject *obj;
23149 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23150 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
23151 Py_INCREF(obj);
23152 return Py_BuildValue((char *)"");
23153 }
23154 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23155 PyObject *resultobj = NULL;
23156 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23157 int arg2 = (int) 0 ;
23158 wxPyCommandEvent *result;
23159 PyObject * obj0 = 0 ;
23160 PyObject * obj1 = 0 ;
23161 char *kwnames[] = {
23162 (char *) "eventType",(char *) "id", NULL
23163 };
23164
23165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
23166 if (obj0) {
23167 {
23168 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
23169 if (SWIG_arg_fail(1)) SWIG_fail;
23170 }
23171 }
23172 if (obj1) {
23173 {
23174 arg2 = static_cast<int >(SWIG_As_int(obj1));
23175 if (SWIG_arg_fail(2)) SWIG_fail;
23176 }
23177 }
23178 {
23179 PyThreadState* __tstate = wxPyBeginAllowThreads();
23180 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
23181
23182 wxPyEndAllowThreads(__tstate);
23183 if (PyErr_Occurred()) SWIG_fail;
23184 }
23185 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
23186 return resultobj;
23187 fail:
23188 return NULL;
23189 }
23190
23191
23192 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23193 PyObject *resultobj = NULL;
23194 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23195 PyObject * obj0 = 0 ;
23196 char *kwnames[] = {
23197 (char *) "self", NULL
23198 };
23199
23200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
23201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23202 if (SWIG_arg_fail(1)) SWIG_fail;
23203 {
23204 PyThreadState* __tstate = wxPyBeginAllowThreads();
23205 delete arg1;
23206
23207 wxPyEndAllowThreads(__tstate);
23208 if (PyErr_Occurred()) SWIG_fail;
23209 }
23210 Py_INCREF(Py_None); resultobj = Py_None;
23211 return resultobj;
23212 fail:
23213 return NULL;
23214 }
23215
23216
23217 static PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23218 PyObject *resultobj = NULL;
23219 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23220 PyObject *arg2 = (PyObject *) 0 ;
23221 PyObject * obj0 = 0 ;
23222 PyObject * obj1 = 0 ;
23223 char *kwnames[] = {
23224 (char *) "self",(char *) "self", NULL
23225 };
23226
23227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23229 if (SWIG_arg_fail(1)) SWIG_fail;
23230 arg2 = obj1;
23231 {
23232 PyThreadState* __tstate = wxPyBeginAllowThreads();
23233 (arg1)->SetSelf(arg2);
23234
23235 wxPyEndAllowThreads(__tstate);
23236 if (PyErr_Occurred()) SWIG_fail;
23237 }
23238 Py_INCREF(Py_None); resultobj = Py_None;
23239 return resultobj;
23240 fail:
23241 return NULL;
23242 }
23243
23244
23245 static PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23246 PyObject *resultobj = NULL;
23247 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23248 PyObject *result;
23249 PyObject * obj0 = 0 ;
23250 char *kwnames[] = {
23251 (char *) "self", NULL
23252 };
23253
23254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent__GetSelf",kwnames,&obj0)) goto fail;
23255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23256 if (SWIG_arg_fail(1)) SWIG_fail;
23257 {
23258 PyThreadState* __tstate = wxPyBeginAllowThreads();
23259 result = (PyObject *)(arg1)->GetSelf();
23260
23261 wxPyEndAllowThreads(__tstate);
23262 if (PyErr_Occurred()) SWIG_fail;
23263 }
23264 resultobj = result;
23265 return resultobj;
23266 fail:
23267 return NULL;
23268 }
23269
23270
23271 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
23272 PyObject *obj;
23273 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23274 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
23275 Py_INCREF(obj);
23276 return Py_BuildValue((char *)"");
23277 }
23278 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23279 PyObject *resultobj = NULL;
23280 wxWindow *arg1 = (wxWindow *) 0 ;
23281 wxDateTime *arg2 = 0 ;
23282 wxEventType arg3 ;
23283 wxDateEvent *result;
23284 PyObject * obj0 = 0 ;
23285 PyObject * obj1 = 0 ;
23286 PyObject * obj2 = 0 ;
23287 char *kwnames[] = {
23288 (char *) "win",(char *) "dt",(char *) "type", NULL
23289 };
23290
23291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
23292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23293 if (SWIG_arg_fail(1)) SWIG_fail;
23294 {
23295 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23296 if (SWIG_arg_fail(2)) SWIG_fail;
23297 if (arg2 == NULL) {
23298 SWIG_null_ref("wxDateTime");
23299 }
23300 if (SWIG_arg_fail(2)) SWIG_fail;
23301 }
23302 {
23303 arg3 = static_cast<wxEventType >(SWIG_As_int(obj2));
23304 if (SWIG_arg_fail(3)) SWIG_fail;
23305 }
23306 {
23307 PyThreadState* __tstate = wxPyBeginAllowThreads();
23308 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
23309
23310 wxPyEndAllowThreads(__tstate);
23311 if (PyErr_Occurred()) SWIG_fail;
23312 }
23313 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
23314 return resultobj;
23315 fail:
23316 return NULL;
23317 }
23318
23319
23320 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23321 PyObject *resultobj = NULL;
23322 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23323 wxDateTime *result;
23324 PyObject * obj0 = 0 ;
23325 char *kwnames[] = {
23326 (char *) "self", NULL
23327 };
23328
23329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
23330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23331 if (SWIG_arg_fail(1)) SWIG_fail;
23332 {
23333 PyThreadState* __tstate = wxPyBeginAllowThreads();
23334 {
23335 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
23336 result = (wxDateTime *) &_result_ref;
23337 }
23338
23339 wxPyEndAllowThreads(__tstate);
23340 if (PyErr_Occurred()) SWIG_fail;
23341 }
23342 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23343 return resultobj;
23344 fail:
23345 return NULL;
23346 }
23347
23348
23349 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23350 PyObject *resultobj = NULL;
23351 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23352 wxDateTime *arg2 = 0 ;
23353 PyObject * obj0 = 0 ;
23354 PyObject * obj1 = 0 ;
23355 char *kwnames[] = {
23356 (char *) "self",(char *) "date", NULL
23357 };
23358
23359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
23360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23361 if (SWIG_arg_fail(1)) SWIG_fail;
23362 {
23363 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23364 if (SWIG_arg_fail(2)) SWIG_fail;
23365 if (arg2 == NULL) {
23366 SWIG_null_ref("wxDateTime");
23367 }
23368 if (SWIG_arg_fail(2)) SWIG_fail;
23369 }
23370 {
23371 PyThreadState* __tstate = wxPyBeginAllowThreads();
23372 (arg1)->SetDate((wxDateTime const &)*arg2);
23373
23374 wxPyEndAllowThreads(__tstate);
23375 if (PyErr_Occurred()) SWIG_fail;
23376 }
23377 Py_INCREF(Py_None); resultobj = Py_None;
23378 return resultobj;
23379 fail:
23380 return NULL;
23381 }
23382
23383
23384 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
23385 PyObject *obj;
23386 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23387 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
23388 Py_INCREF(obj);
23389 return Py_BuildValue((char *)"");
23390 }
23391 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23392 PyObject *resultobj = NULL;
23393 wxPyApp *result;
23394 char *kwnames[] = {
23395 NULL
23396 };
23397
23398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
23399 {
23400 PyThreadState* __tstate = wxPyBeginAllowThreads();
23401 result = (wxPyApp *)new_wxPyApp();
23402
23403 wxPyEndAllowThreads(__tstate);
23404 if (PyErr_Occurred()) SWIG_fail;
23405 }
23406 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
23407 return resultobj;
23408 fail:
23409 return NULL;
23410 }
23411
23412
23413 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23414 PyObject *resultobj = NULL;
23415 wxPyApp *arg1 = (wxPyApp *) 0 ;
23416 PyObject * obj0 = 0 ;
23417 char *kwnames[] = {
23418 (char *) "self", NULL
23419 };
23420
23421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
23422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23423 if (SWIG_arg_fail(1)) SWIG_fail;
23424 {
23425 PyThreadState* __tstate = wxPyBeginAllowThreads();
23426 delete arg1;
23427
23428 wxPyEndAllowThreads(__tstate);
23429 if (PyErr_Occurred()) SWIG_fail;
23430 }
23431 Py_INCREF(Py_None); resultobj = Py_None;
23432 return resultobj;
23433 fail:
23434 return NULL;
23435 }
23436
23437
23438 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
23439 PyObject *resultobj = NULL;
23440 wxPyApp *arg1 = (wxPyApp *) 0 ;
23441 PyObject *arg2 = (PyObject *) 0 ;
23442 PyObject *arg3 = (PyObject *) 0 ;
23443 bool arg4 ;
23444 PyObject * obj0 = 0 ;
23445 PyObject * obj1 = 0 ;
23446 PyObject * obj2 = 0 ;
23447 PyObject * obj3 = 0 ;
23448 char *kwnames[] = {
23449 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
23450 };
23451
23452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23454 if (SWIG_arg_fail(1)) SWIG_fail;
23455 arg2 = obj1;
23456 arg3 = obj2;
23457 {
23458 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
23459 if (SWIG_arg_fail(4)) SWIG_fail;
23460 }
23461 {
23462 PyThreadState* __tstate = wxPyBeginAllowThreads();
23463 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
23464
23465 wxPyEndAllowThreads(__tstate);
23466 if (PyErr_Occurred()) SWIG_fail;
23467 }
23468 Py_INCREF(Py_None); resultobj = Py_None;
23469 return resultobj;
23470 fail:
23471 return NULL;
23472 }
23473
23474
23475 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23476 PyObject *resultobj = NULL;
23477 wxPyApp *arg1 = (wxPyApp *) 0 ;
23478 wxString result;
23479 PyObject * obj0 = 0 ;
23480 char *kwnames[] = {
23481 (char *) "self", NULL
23482 };
23483
23484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
23485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23486 if (SWIG_arg_fail(1)) SWIG_fail;
23487 {
23488 PyThreadState* __tstate = wxPyBeginAllowThreads();
23489 result = ((wxPyApp const *)arg1)->GetAppName();
23490
23491 wxPyEndAllowThreads(__tstate);
23492 if (PyErr_Occurred()) SWIG_fail;
23493 }
23494 {
23495 #if wxUSE_UNICODE
23496 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23497 #else
23498 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23499 #endif
23500 }
23501 return resultobj;
23502 fail:
23503 return NULL;
23504 }
23505
23506
23507 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23508 PyObject *resultobj = NULL;
23509 wxPyApp *arg1 = (wxPyApp *) 0 ;
23510 wxString *arg2 = 0 ;
23511 bool temp2 = false ;
23512 PyObject * obj0 = 0 ;
23513 PyObject * obj1 = 0 ;
23514 char *kwnames[] = {
23515 (char *) "self",(char *) "name", NULL
23516 };
23517
23518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
23519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23520 if (SWIG_arg_fail(1)) SWIG_fail;
23521 {
23522 arg2 = wxString_in_helper(obj1);
23523 if (arg2 == NULL) SWIG_fail;
23524 temp2 = true;
23525 }
23526 {
23527 PyThreadState* __tstate = wxPyBeginAllowThreads();
23528 (arg1)->SetAppName((wxString const &)*arg2);
23529
23530 wxPyEndAllowThreads(__tstate);
23531 if (PyErr_Occurred()) SWIG_fail;
23532 }
23533 Py_INCREF(Py_None); resultobj = Py_None;
23534 {
23535 if (temp2)
23536 delete arg2;
23537 }
23538 return resultobj;
23539 fail:
23540 {
23541 if (temp2)
23542 delete arg2;
23543 }
23544 return NULL;
23545 }
23546
23547
23548 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23549 PyObject *resultobj = NULL;
23550 wxPyApp *arg1 = (wxPyApp *) 0 ;
23551 wxString result;
23552 PyObject * obj0 = 0 ;
23553 char *kwnames[] = {
23554 (char *) "self", NULL
23555 };
23556
23557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
23558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23559 if (SWIG_arg_fail(1)) SWIG_fail;
23560 {
23561 PyThreadState* __tstate = wxPyBeginAllowThreads();
23562 result = ((wxPyApp const *)arg1)->GetClassName();
23563
23564 wxPyEndAllowThreads(__tstate);
23565 if (PyErr_Occurred()) SWIG_fail;
23566 }
23567 {
23568 #if wxUSE_UNICODE
23569 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23570 #else
23571 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23572 #endif
23573 }
23574 return resultobj;
23575 fail:
23576 return NULL;
23577 }
23578
23579
23580 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23581 PyObject *resultobj = NULL;
23582 wxPyApp *arg1 = (wxPyApp *) 0 ;
23583 wxString *arg2 = 0 ;
23584 bool temp2 = false ;
23585 PyObject * obj0 = 0 ;
23586 PyObject * obj1 = 0 ;
23587 char *kwnames[] = {
23588 (char *) "self",(char *) "name", NULL
23589 };
23590
23591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
23592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23593 if (SWIG_arg_fail(1)) SWIG_fail;
23594 {
23595 arg2 = wxString_in_helper(obj1);
23596 if (arg2 == NULL) SWIG_fail;
23597 temp2 = true;
23598 }
23599 {
23600 PyThreadState* __tstate = wxPyBeginAllowThreads();
23601 (arg1)->SetClassName((wxString const &)*arg2);
23602
23603 wxPyEndAllowThreads(__tstate);
23604 if (PyErr_Occurred()) SWIG_fail;
23605 }
23606 Py_INCREF(Py_None); resultobj = Py_None;
23607 {
23608 if (temp2)
23609 delete arg2;
23610 }
23611 return resultobj;
23612 fail:
23613 {
23614 if (temp2)
23615 delete arg2;
23616 }
23617 return NULL;
23618 }
23619
23620
23621 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23622 PyObject *resultobj = NULL;
23623 wxPyApp *arg1 = (wxPyApp *) 0 ;
23624 wxString *result;
23625 PyObject * obj0 = 0 ;
23626 char *kwnames[] = {
23627 (char *) "self", NULL
23628 };
23629
23630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
23631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23632 if (SWIG_arg_fail(1)) SWIG_fail;
23633 {
23634 PyThreadState* __tstate = wxPyBeginAllowThreads();
23635 {
23636 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
23637 result = (wxString *) &_result_ref;
23638 }
23639
23640 wxPyEndAllowThreads(__tstate);
23641 if (PyErr_Occurred()) SWIG_fail;
23642 }
23643 {
23644 #if wxUSE_UNICODE
23645 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23646 #else
23647 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23648 #endif
23649 }
23650 return resultobj;
23651 fail:
23652 return NULL;
23653 }
23654
23655
23656 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23657 PyObject *resultobj = NULL;
23658 wxPyApp *arg1 = (wxPyApp *) 0 ;
23659 wxString *arg2 = 0 ;
23660 bool temp2 = false ;
23661 PyObject * obj0 = 0 ;
23662 PyObject * obj1 = 0 ;
23663 char *kwnames[] = {
23664 (char *) "self",(char *) "name", NULL
23665 };
23666
23667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
23668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23669 if (SWIG_arg_fail(1)) SWIG_fail;
23670 {
23671 arg2 = wxString_in_helper(obj1);
23672 if (arg2 == NULL) SWIG_fail;
23673 temp2 = true;
23674 }
23675 {
23676 PyThreadState* __tstate = wxPyBeginAllowThreads();
23677 (arg1)->SetVendorName((wxString const &)*arg2);
23678
23679 wxPyEndAllowThreads(__tstate);
23680 if (PyErr_Occurred()) SWIG_fail;
23681 }
23682 Py_INCREF(Py_None); resultobj = Py_None;
23683 {
23684 if (temp2)
23685 delete arg2;
23686 }
23687 return resultobj;
23688 fail:
23689 {
23690 if (temp2)
23691 delete arg2;
23692 }
23693 return NULL;
23694 }
23695
23696
23697 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
23698 PyObject *resultobj = NULL;
23699 wxPyApp *arg1 = (wxPyApp *) 0 ;
23700 wxAppTraits *result;
23701 PyObject * obj0 = 0 ;
23702 char *kwnames[] = {
23703 (char *) "self", NULL
23704 };
23705
23706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
23707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23708 if (SWIG_arg_fail(1)) SWIG_fail;
23709 {
23710 PyThreadState* __tstate = wxPyBeginAllowThreads();
23711 result = (wxAppTraits *)(arg1)->GetTraits();
23712
23713 wxPyEndAllowThreads(__tstate);
23714 if (PyErr_Occurred()) SWIG_fail;
23715 }
23716 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
23717 return resultobj;
23718 fail:
23719 return NULL;
23720 }
23721
23722
23723 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23724 PyObject *resultobj = NULL;
23725 wxPyApp *arg1 = (wxPyApp *) 0 ;
23726 PyObject * obj0 = 0 ;
23727 char *kwnames[] = {
23728 (char *) "self", NULL
23729 };
23730
23731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
23732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23733 if (SWIG_arg_fail(1)) SWIG_fail;
23734 {
23735 PyThreadState* __tstate = wxPyBeginAllowThreads();
23736 (arg1)->ProcessPendingEvents();
23737
23738 wxPyEndAllowThreads(__tstate);
23739 if (PyErr_Occurred()) SWIG_fail;
23740 }
23741 Py_INCREF(Py_None); resultobj = Py_None;
23742 return resultobj;
23743 fail:
23744 return NULL;
23745 }
23746
23747
23748 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23749 PyObject *resultobj = NULL;
23750 wxPyApp *arg1 = (wxPyApp *) 0 ;
23751 bool arg2 = (bool) false ;
23752 bool result;
23753 PyObject * obj0 = 0 ;
23754 PyObject * obj1 = 0 ;
23755 char *kwnames[] = {
23756 (char *) "self",(char *) "onlyIfNeeded", NULL
23757 };
23758
23759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
23760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23761 if (SWIG_arg_fail(1)) SWIG_fail;
23762 if (obj1) {
23763 {
23764 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
23765 if (SWIG_arg_fail(2)) SWIG_fail;
23766 }
23767 }
23768 {
23769 PyThreadState* __tstate = wxPyBeginAllowThreads();
23770 result = (bool)(arg1)->Yield(arg2);
23771
23772 wxPyEndAllowThreads(__tstate);
23773 if (PyErr_Occurred()) SWIG_fail;
23774 }
23775 {
23776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23777 }
23778 return resultobj;
23779 fail:
23780 return NULL;
23781 }
23782
23783
23784 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23785 PyObject *resultobj = NULL;
23786 wxPyApp *arg1 = (wxPyApp *) 0 ;
23787 PyObject * obj0 = 0 ;
23788 char *kwnames[] = {
23789 (char *) "self", NULL
23790 };
23791
23792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23794 if (SWIG_arg_fail(1)) SWIG_fail;
23795 {
23796 PyThreadState* __tstate = wxPyBeginAllowThreads();
23797 (arg1)->WakeUpIdle();
23798
23799 wxPyEndAllowThreads(__tstate);
23800 if (PyErr_Occurred()) SWIG_fail;
23801 }
23802 Py_INCREF(Py_None); resultobj = Py_None;
23803 return resultobj;
23804 fail:
23805 return NULL;
23806 }
23807
23808
23809 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23810 PyObject *resultobj = NULL;
23811 bool result;
23812 char *kwnames[] = {
23813 NULL
23814 };
23815
23816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23817 {
23818 PyThreadState* __tstate = wxPyBeginAllowThreads();
23819 result = (bool)wxPyApp::IsMainLoopRunning();
23820
23821 wxPyEndAllowThreads(__tstate);
23822 if (PyErr_Occurred()) SWIG_fail;
23823 }
23824 {
23825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23826 }
23827 return resultobj;
23828 fail:
23829 return NULL;
23830 }
23831
23832
23833 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23834 PyObject *resultobj = NULL;
23835 wxPyApp *arg1 = (wxPyApp *) 0 ;
23836 int result;
23837 PyObject * obj0 = 0 ;
23838 char *kwnames[] = {
23839 (char *) "self", NULL
23840 };
23841
23842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23844 if (SWIG_arg_fail(1)) SWIG_fail;
23845 {
23846 PyThreadState* __tstate = wxPyBeginAllowThreads();
23847 result = (int)(arg1)->MainLoop();
23848
23849 wxPyEndAllowThreads(__tstate);
23850 if (PyErr_Occurred()) SWIG_fail;
23851 }
23852 {
23853 resultobj = SWIG_From_int(static_cast<int >(result));
23854 }
23855 return resultobj;
23856 fail:
23857 return NULL;
23858 }
23859
23860
23861 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23862 PyObject *resultobj = NULL;
23863 wxPyApp *arg1 = (wxPyApp *) 0 ;
23864 PyObject * obj0 = 0 ;
23865 char *kwnames[] = {
23866 (char *) "self", NULL
23867 };
23868
23869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23871 if (SWIG_arg_fail(1)) SWIG_fail;
23872 {
23873 PyThreadState* __tstate = wxPyBeginAllowThreads();
23874 (arg1)->Exit();
23875
23876 wxPyEndAllowThreads(__tstate);
23877 if (PyErr_Occurred()) SWIG_fail;
23878 }
23879 Py_INCREF(Py_None); resultobj = Py_None;
23880 return resultobj;
23881 fail:
23882 return NULL;
23883 }
23884
23885
23886 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23887 PyObject *resultobj = NULL;
23888 wxPyApp *arg1 = (wxPyApp *) 0 ;
23889 PyObject * obj0 = 0 ;
23890 char *kwnames[] = {
23891 (char *) "self", NULL
23892 };
23893
23894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23896 if (SWIG_arg_fail(1)) SWIG_fail;
23897 {
23898 PyThreadState* __tstate = wxPyBeginAllowThreads();
23899 (arg1)->ExitMainLoop();
23900
23901 wxPyEndAllowThreads(__tstate);
23902 if (PyErr_Occurred()) SWIG_fail;
23903 }
23904 Py_INCREF(Py_None); resultobj = Py_None;
23905 return resultobj;
23906 fail:
23907 return NULL;
23908 }
23909
23910
23911 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23912 PyObject *resultobj = NULL;
23913 wxPyApp *arg1 = (wxPyApp *) 0 ;
23914 bool result;
23915 PyObject * obj0 = 0 ;
23916 char *kwnames[] = {
23917 (char *) "self", NULL
23918 };
23919
23920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23922 if (SWIG_arg_fail(1)) SWIG_fail;
23923 {
23924 PyThreadState* __tstate = wxPyBeginAllowThreads();
23925 result = (bool)(arg1)->Pending();
23926
23927 wxPyEndAllowThreads(__tstate);
23928 if (PyErr_Occurred()) SWIG_fail;
23929 }
23930 {
23931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23932 }
23933 return resultobj;
23934 fail:
23935 return NULL;
23936 }
23937
23938
23939 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23940 PyObject *resultobj = NULL;
23941 wxPyApp *arg1 = (wxPyApp *) 0 ;
23942 bool result;
23943 PyObject * obj0 = 0 ;
23944 char *kwnames[] = {
23945 (char *) "self", NULL
23946 };
23947
23948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23950 if (SWIG_arg_fail(1)) SWIG_fail;
23951 {
23952 PyThreadState* __tstate = wxPyBeginAllowThreads();
23953 result = (bool)(arg1)->Dispatch();
23954
23955 wxPyEndAllowThreads(__tstate);
23956 if (PyErr_Occurred()) SWIG_fail;
23957 }
23958 {
23959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23960 }
23961 return resultobj;
23962 fail:
23963 return NULL;
23964 }
23965
23966
23967 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23968 PyObject *resultobj = NULL;
23969 wxPyApp *arg1 = (wxPyApp *) 0 ;
23970 bool result;
23971 PyObject * obj0 = 0 ;
23972 char *kwnames[] = {
23973 (char *) "self", NULL
23974 };
23975
23976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23978 if (SWIG_arg_fail(1)) SWIG_fail;
23979 {
23980 PyThreadState* __tstate = wxPyBeginAllowThreads();
23981 result = (bool)(arg1)->ProcessIdle();
23982
23983 wxPyEndAllowThreads(__tstate);
23984 if (PyErr_Occurred()) SWIG_fail;
23985 }
23986 {
23987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23988 }
23989 return resultobj;
23990 fail:
23991 return NULL;
23992 }
23993
23994
23995 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23996 PyObject *resultobj = NULL;
23997 wxPyApp *arg1 = (wxPyApp *) 0 ;
23998 wxWindow *arg2 = (wxWindow *) 0 ;
23999 wxIdleEvent *arg3 = 0 ;
24000 bool result;
24001 PyObject * obj0 = 0 ;
24002 PyObject * obj1 = 0 ;
24003 PyObject * obj2 = 0 ;
24004 char *kwnames[] = {
24005 (char *) "self",(char *) "win",(char *) "event", NULL
24006 };
24007
24008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
24009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24010 if (SWIG_arg_fail(1)) SWIG_fail;
24011 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24012 if (SWIG_arg_fail(2)) SWIG_fail;
24013 {
24014 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
24015 if (SWIG_arg_fail(3)) SWIG_fail;
24016 if (arg3 == NULL) {
24017 SWIG_null_ref("wxIdleEvent");
24018 }
24019 if (SWIG_arg_fail(3)) SWIG_fail;
24020 }
24021 {
24022 PyThreadState* __tstate = wxPyBeginAllowThreads();
24023 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
24024
24025 wxPyEndAllowThreads(__tstate);
24026 if (PyErr_Occurred()) SWIG_fail;
24027 }
24028 {
24029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24030 }
24031 return resultobj;
24032 fail:
24033 return NULL;
24034 }
24035
24036
24037 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
24038 PyObject *resultobj = NULL;
24039 wxPyApp *arg1 = (wxPyApp *) 0 ;
24040 bool result;
24041 PyObject * obj0 = 0 ;
24042 char *kwnames[] = {
24043 (char *) "self", NULL
24044 };
24045
24046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
24047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24048 if (SWIG_arg_fail(1)) SWIG_fail;
24049 {
24050 PyThreadState* __tstate = wxPyBeginAllowThreads();
24051 result = (bool)((wxPyApp const *)arg1)->IsActive();
24052
24053 wxPyEndAllowThreads(__tstate);
24054 if (PyErr_Occurred()) SWIG_fail;
24055 }
24056 {
24057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24058 }
24059 return resultobj;
24060 fail:
24061 return NULL;
24062 }
24063
24064
24065 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24066 PyObject *resultobj = NULL;
24067 wxPyApp *arg1 = (wxPyApp *) 0 ;
24068 wxWindow *arg2 = (wxWindow *) 0 ;
24069 PyObject * obj0 = 0 ;
24070 PyObject * obj1 = 0 ;
24071 char *kwnames[] = {
24072 (char *) "self",(char *) "win", NULL
24073 };
24074
24075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
24076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24077 if (SWIG_arg_fail(1)) SWIG_fail;
24078 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24079 if (SWIG_arg_fail(2)) SWIG_fail;
24080 {
24081 PyThreadState* __tstate = wxPyBeginAllowThreads();
24082 (arg1)->SetTopWindow(arg2);
24083
24084 wxPyEndAllowThreads(__tstate);
24085 if (PyErr_Occurred()) SWIG_fail;
24086 }
24087 Py_INCREF(Py_None); resultobj = Py_None;
24088 return resultobj;
24089 fail:
24090 return NULL;
24091 }
24092
24093
24094 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24095 PyObject *resultobj = NULL;
24096 wxPyApp *arg1 = (wxPyApp *) 0 ;
24097 wxWindow *result;
24098 PyObject * obj0 = 0 ;
24099 char *kwnames[] = {
24100 (char *) "self", NULL
24101 };
24102
24103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
24104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24105 if (SWIG_arg_fail(1)) SWIG_fail;
24106 {
24107 PyThreadState* __tstate = wxPyBeginAllowThreads();
24108 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
24109
24110 wxPyEndAllowThreads(__tstate);
24111 if (PyErr_Occurred()) SWIG_fail;
24112 }
24113 {
24114 resultobj = wxPyMake_wxObject(result, 0);
24115 }
24116 return resultobj;
24117 fail:
24118 return NULL;
24119 }
24120
24121
24122 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
24123 PyObject *resultobj = NULL;
24124 wxPyApp *arg1 = (wxPyApp *) 0 ;
24125 bool arg2 ;
24126 PyObject * obj0 = 0 ;
24127 PyObject * obj1 = 0 ;
24128 char *kwnames[] = {
24129 (char *) "self",(char *) "flag", NULL
24130 };
24131
24132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
24133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24134 if (SWIG_arg_fail(1)) SWIG_fail;
24135 {
24136 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24137 if (SWIG_arg_fail(2)) SWIG_fail;
24138 }
24139 {
24140 PyThreadState* __tstate = wxPyBeginAllowThreads();
24141 (arg1)->SetExitOnFrameDelete(arg2);
24142
24143 wxPyEndAllowThreads(__tstate);
24144 if (PyErr_Occurred()) SWIG_fail;
24145 }
24146 Py_INCREF(Py_None); resultobj = Py_None;
24147 return resultobj;
24148 fail:
24149 return NULL;
24150 }
24151
24152
24153 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
24154 PyObject *resultobj = NULL;
24155 wxPyApp *arg1 = (wxPyApp *) 0 ;
24156 bool result;
24157 PyObject * obj0 = 0 ;
24158 char *kwnames[] = {
24159 (char *) "self", NULL
24160 };
24161
24162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
24163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24164 if (SWIG_arg_fail(1)) SWIG_fail;
24165 {
24166 PyThreadState* __tstate = wxPyBeginAllowThreads();
24167 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
24168
24169 wxPyEndAllowThreads(__tstate);
24170 if (PyErr_Occurred()) SWIG_fail;
24171 }
24172 {
24173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24174 }
24175 return resultobj;
24176 fail:
24177 return NULL;
24178 }
24179
24180
24181 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24182 PyObject *resultobj = NULL;
24183 wxPyApp *arg1 = (wxPyApp *) 0 ;
24184 bool arg2 ;
24185 PyObject * obj0 = 0 ;
24186 PyObject * obj1 = 0 ;
24187 char *kwnames[] = {
24188 (char *) "self",(char *) "flag", NULL
24189 };
24190
24191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
24192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24193 if (SWIG_arg_fail(1)) SWIG_fail;
24194 {
24195 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24196 if (SWIG_arg_fail(2)) SWIG_fail;
24197 }
24198 {
24199 PyThreadState* __tstate = wxPyBeginAllowThreads();
24200 (arg1)->SetUseBestVisual(arg2);
24201
24202 wxPyEndAllowThreads(__tstate);
24203 if (PyErr_Occurred()) SWIG_fail;
24204 }
24205 Py_INCREF(Py_None); resultobj = Py_None;
24206 return resultobj;
24207 fail:
24208 return NULL;
24209 }
24210
24211
24212 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24213 PyObject *resultobj = NULL;
24214 wxPyApp *arg1 = (wxPyApp *) 0 ;
24215 bool result;
24216 PyObject * obj0 = 0 ;
24217 char *kwnames[] = {
24218 (char *) "self", NULL
24219 };
24220
24221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
24222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24223 if (SWIG_arg_fail(1)) SWIG_fail;
24224 {
24225 PyThreadState* __tstate = wxPyBeginAllowThreads();
24226 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
24227
24228 wxPyEndAllowThreads(__tstate);
24229 if (PyErr_Occurred()) SWIG_fail;
24230 }
24231 {
24232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24233 }
24234 return resultobj;
24235 fail:
24236 return NULL;
24237 }
24238
24239
24240 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24241 PyObject *resultobj = NULL;
24242 wxPyApp *arg1 = (wxPyApp *) 0 ;
24243 int arg2 ;
24244 PyObject * obj0 = 0 ;
24245 PyObject * obj1 = 0 ;
24246 char *kwnames[] = {
24247 (char *) "self",(char *) "mode", NULL
24248 };
24249
24250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
24251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24252 if (SWIG_arg_fail(1)) SWIG_fail;
24253 {
24254 arg2 = static_cast<int >(SWIG_As_int(obj1));
24255 if (SWIG_arg_fail(2)) SWIG_fail;
24256 }
24257 {
24258 PyThreadState* __tstate = wxPyBeginAllowThreads();
24259 (arg1)->SetPrintMode(arg2);
24260
24261 wxPyEndAllowThreads(__tstate);
24262 if (PyErr_Occurred()) SWIG_fail;
24263 }
24264 Py_INCREF(Py_None); resultobj = Py_None;
24265 return resultobj;
24266 fail:
24267 return NULL;
24268 }
24269
24270
24271 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24272 PyObject *resultobj = NULL;
24273 wxPyApp *arg1 = (wxPyApp *) 0 ;
24274 int result;
24275 PyObject * obj0 = 0 ;
24276 char *kwnames[] = {
24277 (char *) "self", NULL
24278 };
24279
24280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
24281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24282 if (SWIG_arg_fail(1)) SWIG_fail;
24283 {
24284 PyThreadState* __tstate = wxPyBeginAllowThreads();
24285 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
24286
24287 wxPyEndAllowThreads(__tstate);
24288 if (PyErr_Occurred()) SWIG_fail;
24289 }
24290 {
24291 resultobj = SWIG_From_int(static_cast<int >(result));
24292 }
24293 return resultobj;
24294 fail:
24295 return NULL;
24296 }
24297
24298
24299 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24300 PyObject *resultobj = NULL;
24301 wxPyApp *arg1 = (wxPyApp *) 0 ;
24302 int arg2 ;
24303 PyObject * obj0 = 0 ;
24304 PyObject * obj1 = 0 ;
24305 char *kwnames[] = {
24306 (char *) "self",(char *) "mode", NULL
24307 };
24308
24309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
24310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24311 if (SWIG_arg_fail(1)) SWIG_fail;
24312 {
24313 arg2 = static_cast<int >(SWIG_As_int(obj1));
24314 if (SWIG_arg_fail(2)) SWIG_fail;
24315 }
24316 {
24317 PyThreadState* __tstate = wxPyBeginAllowThreads();
24318 (arg1)->SetAssertMode(arg2);
24319
24320 wxPyEndAllowThreads(__tstate);
24321 if (PyErr_Occurred()) SWIG_fail;
24322 }
24323 Py_INCREF(Py_None); resultobj = Py_None;
24324 return resultobj;
24325 fail:
24326 return NULL;
24327 }
24328
24329
24330 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24331 PyObject *resultobj = NULL;
24332 wxPyApp *arg1 = (wxPyApp *) 0 ;
24333 int result;
24334 PyObject * obj0 = 0 ;
24335 char *kwnames[] = {
24336 (char *) "self", NULL
24337 };
24338
24339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
24340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24341 if (SWIG_arg_fail(1)) SWIG_fail;
24342 {
24343 PyThreadState* __tstate = wxPyBeginAllowThreads();
24344 result = (int)(arg1)->GetAssertMode();
24345
24346 wxPyEndAllowThreads(__tstate);
24347 if (PyErr_Occurred()) SWIG_fail;
24348 }
24349 {
24350 resultobj = SWIG_From_int(static_cast<int >(result));
24351 }
24352 return resultobj;
24353 fail:
24354 return NULL;
24355 }
24356
24357
24358 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24359 PyObject *resultobj = NULL;
24360 bool result;
24361 char *kwnames[] = {
24362 NULL
24363 };
24364
24365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
24366 {
24367 PyThreadState* __tstate = wxPyBeginAllowThreads();
24368 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
24369
24370 wxPyEndAllowThreads(__tstate);
24371 if (PyErr_Occurred()) SWIG_fail;
24372 }
24373 {
24374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24375 }
24376 return resultobj;
24377 fail:
24378 return NULL;
24379 }
24380
24381
24382 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24383 PyObject *resultobj = NULL;
24384 long result;
24385 char *kwnames[] = {
24386 NULL
24387 };
24388
24389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
24390 {
24391 PyThreadState* __tstate = wxPyBeginAllowThreads();
24392 result = (long)wxPyApp::GetMacAboutMenuItemId();
24393
24394 wxPyEndAllowThreads(__tstate);
24395 if (PyErr_Occurred()) SWIG_fail;
24396 }
24397 {
24398 resultobj = SWIG_From_long(static_cast<long >(result));
24399 }
24400 return resultobj;
24401 fail:
24402 return NULL;
24403 }
24404
24405
24406 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24407 PyObject *resultobj = NULL;
24408 long result;
24409 char *kwnames[] = {
24410 NULL
24411 };
24412
24413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
24414 {
24415 PyThreadState* __tstate = wxPyBeginAllowThreads();
24416 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
24417
24418 wxPyEndAllowThreads(__tstate);
24419 if (PyErr_Occurred()) SWIG_fail;
24420 }
24421 {
24422 resultobj = SWIG_From_long(static_cast<long >(result));
24423 }
24424 return resultobj;
24425 fail:
24426 return NULL;
24427 }
24428
24429
24430 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24431 PyObject *resultobj = NULL;
24432 long result;
24433 char *kwnames[] = {
24434 NULL
24435 };
24436
24437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
24438 {
24439 PyThreadState* __tstate = wxPyBeginAllowThreads();
24440 result = (long)wxPyApp::GetMacExitMenuItemId();
24441
24442 wxPyEndAllowThreads(__tstate);
24443 if (PyErr_Occurred()) SWIG_fail;
24444 }
24445 {
24446 resultobj = SWIG_From_long(static_cast<long >(result));
24447 }
24448 return resultobj;
24449 fail:
24450 return NULL;
24451 }
24452
24453
24454 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24455 PyObject *resultobj = NULL;
24456 wxString result;
24457 char *kwnames[] = {
24458 NULL
24459 };
24460
24461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
24462 {
24463 PyThreadState* __tstate = wxPyBeginAllowThreads();
24464 result = wxPyApp::GetMacHelpMenuTitleName();
24465
24466 wxPyEndAllowThreads(__tstate);
24467 if (PyErr_Occurred()) SWIG_fail;
24468 }
24469 {
24470 #if wxUSE_UNICODE
24471 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24472 #else
24473 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24474 #endif
24475 }
24476 return resultobj;
24477 fail:
24478 return NULL;
24479 }
24480
24481
24482 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24483 PyObject *resultobj = NULL;
24484 bool arg1 ;
24485 PyObject * obj0 = 0 ;
24486 char *kwnames[] = {
24487 (char *) "val", NULL
24488 };
24489
24490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
24491 {
24492 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
24493 if (SWIG_arg_fail(1)) SWIG_fail;
24494 }
24495 {
24496 PyThreadState* __tstate = wxPyBeginAllowThreads();
24497 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
24498
24499 wxPyEndAllowThreads(__tstate);
24500 if (PyErr_Occurred()) SWIG_fail;
24501 }
24502 Py_INCREF(Py_None); resultobj = Py_None;
24503 return resultobj;
24504 fail:
24505 return NULL;
24506 }
24507
24508
24509 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24510 PyObject *resultobj = NULL;
24511 long arg1 ;
24512 PyObject * obj0 = 0 ;
24513 char *kwnames[] = {
24514 (char *) "val", NULL
24515 };
24516
24517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
24518 {
24519 arg1 = static_cast<long >(SWIG_As_long(obj0));
24520 if (SWIG_arg_fail(1)) SWIG_fail;
24521 }
24522 {
24523 PyThreadState* __tstate = wxPyBeginAllowThreads();
24524 wxPyApp::SetMacAboutMenuItemId(arg1);
24525
24526 wxPyEndAllowThreads(__tstate);
24527 if (PyErr_Occurred()) SWIG_fail;
24528 }
24529 Py_INCREF(Py_None); resultobj = Py_None;
24530 return resultobj;
24531 fail:
24532 return NULL;
24533 }
24534
24535
24536 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24537 PyObject *resultobj = NULL;
24538 long arg1 ;
24539 PyObject * obj0 = 0 ;
24540 char *kwnames[] = {
24541 (char *) "val", NULL
24542 };
24543
24544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
24545 {
24546 arg1 = static_cast<long >(SWIG_As_long(obj0));
24547 if (SWIG_arg_fail(1)) SWIG_fail;
24548 }
24549 {
24550 PyThreadState* __tstate = wxPyBeginAllowThreads();
24551 wxPyApp::SetMacPreferencesMenuItemId(arg1);
24552
24553 wxPyEndAllowThreads(__tstate);
24554 if (PyErr_Occurred()) SWIG_fail;
24555 }
24556 Py_INCREF(Py_None); resultobj = Py_None;
24557 return resultobj;
24558 fail:
24559 return NULL;
24560 }
24561
24562
24563 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24564 PyObject *resultobj = NULL;
24565 long arg1 ;
24566 PyObject * obj0 = 0 ;
24567 char *kwnames[] = {
24568 (char *) "val", NULL
24569 };
24570
24571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
24572 {
24573 arg1 = static_cast<long >(SWIG_As_long(obj0));
24574 if (SWIG_arg_fail(1)) SWIG_fail;
24575 }
24576 {
24577 PyThreadState* __tstate = wxPyBeginAllowThreads();
24578 wxPyApp::SetMacExitMenuItemId(arg1);
24579
24580 wxPyEndAllowThreads(__tstate);
24581 if (PyErr_Occurred()) SWIG_fail;
24582 }
24583 Py_INCREF(Py_None); resultobj = Py_None;
24584 return resultobj;
24585 fail:
24586 return NULL;
24587 }
24588
24589
24590 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24591 PyObject *resultobj = NULL;
24592 wxString *arg1 = 0 ;
24593 bool temp1 = false ;
24594 PyObject * obj0 = 0 ;
24595 char *kwnames[] = {
24596 (char *) "val", NULL
24597 };
24598
24599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
24600 {
24601 arg1 = wxString_in_helper(obj0);
24602 if (arg1 == NULL) SWIG_fail;
24603 temp1 = true;
24604 }
24605 {
24606 PyThreadState* __tstate = wxPyBeginAllowThreads();
24607 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
24608
24609 wxPyEndAllowThreads(__tstate);
24610 if (PyErr_Occurred()) SWIG_fail;
24611 }
24612 Py_INCREF(Py_None); resultobj = Py_None;
24613 {
24614 if (temp1)
24615 delete arg1;
24616 }
24617 return resultobj;
24618 fail:
24619 {
24620 if (temp1)
24621 delete arg1;
24622 }
24623 return NULL;
24624 }
24625
24626
24627 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
24628 PyObject *resultobj = NULL;
24629 wxPyApp *arg1 = (wxPyApp *) 0 ;
24630 PyObject * obj0 = 0 ;
24631 char *kwnames[] = {
24632 (char *) "self", NULL
24633 };
24634
24635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
24636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24637 if (SWIG_arg_fail(1)) SWIG_fail;
24638 {
24639 PyThreadState* __tstate = wxPyBeginAllowThreads();
24640 (arg1)->_BootstrapApp();
24641
24642 wxPyEndAllowThreads(__tstate);
24643 if (PyErr_Occurred()) SWIG_fail;
24644 }
24645 Py_INCREF(Py_None); resultobj = Py_None;
24646 return resultobj;
24647 fail:
24648 return NULL;
24649 }
24650
24651
24652 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
24653 PyObject *resultobj = NULL;
24654 int result;
24655 char *kwnames[] = {
24656 NULL
24657 };
24658
24659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
24660 {
24661 PyThreadState* __tstate = wxPyBeginAllowThreads();
24662 result = (int)wxPyApp_GetComCtl32Version();
24663
24664 wxPyEndAllowThreads(__tstate);
24665 if (PyErr_Occurred()) SWIG_fail;
24666 }
24667 {
24668 resultobj = SWIG_From_int(static_cast<int >(result));
24669 }
24670 return resultobj;
24671 fail:
24672 return NULL;
24673 }
24674
24675
24676 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
24677 PyObject *obj;
24678 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24679 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
24680 Py_INCREF(obj);
24681 return Py_BuildValue((char *)"");
24682 }
24683 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24684 PyObject *resultobj = NULL;
24685 char *kwnames[] = {
24686 NULL
24687 };
24688
24689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
24690 {
24691 PyThreadState* __tstate = wxPyBeginAllowThreads();
24692 wxExit();
24693
24694 wxPyEndAllowThreads(__tstate);
24695 if (PyErr_Occurred()) SWIG_fail;
24696 }
24697 Py_INCREF(Py_None); resultobj = Py_None;
24698 return resultobj;
24699 fail:
24700 return NULL;
24701 }
24702
24703
24704 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
24705 PyObject *resultobj = NULL;
24706 bool result;
24707 char *kwnames[] = {
24708 NULL
24709 };
24710
24711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
24712 {
24713 PyThreadState* __tstate = wxPyBeginAllowThreads();
24714 result = (bool)wxYield();
24715
24716 wxPyEndAllowThreads(__tstate);
24717 if (PyErr_Occurred()) SWIG_fail;
24718 }
24719 {
24720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24721 }
24722 return resultobj;
24723 fail:
24724 return NULL;
24725 }
24726
24727
24728 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
24729 PyObject *resultobj = NULL;
24730 bool result;
24731 char *kwnames[] = {
24732 NULL
24733 };
24734
24735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
24736 {
24737 PyThreadState* __tstate = wxPyBeginAllowThreads();
24738 result = (bool)wxYieldIfNeeded();
24739
24740 wxPyEndAllowThreads(__tstate);
24741 if (PyErr_Occurred()) SWIG_fail;
24742 }
24743 {
24744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24745 }
24746 return resultobj;
24747 fail:
24748 return NULL;
24749 }
24750
24751
24752 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
24753 PyObject *resultobj = NULL;
24754 wxWindow *arg1 = (wxWindow *) NULL ;
24755 bool arg2 = (bool) false ;
24756 bool result;
24757 PyObject * obj0 = 0 ;
24758 PyObject * obj1 = 0 ;
24759 char *kwnames[] = {
24760 (char *) "win",(char *) "onlyIfNeeded", NULL
24761 };
24762
24763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24764 if (obj0) {
24765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24766 if (SWIG_arg_fail(1)) SWIG_fail;
24767 }
24768 if (obj1) {
24769 {
24770 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24771 if (SWIG_arg_fail(2)) SWIG_fail;
24772 }
24773 }
24774 {
24775 PyThreadState* __tstate = wxPyBeginAllowThreads();
24776 result = (bool)wxSafeYield(arg1,arg2);
24777
24778 wxPyEndAllowThreads(__tstate);
24779 if (PyErr_Occurred()) SWIG_fail;
24780 }
24781 {
24782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24783 }
24784 return resultobj;
24785 fail:
24786 return NULL;
24787 }
24788
24789
24790 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24791 PyObject *resultobj = NULL;
24792 char *kwnames[] = {
24793 NULL
24794 };
24795
24796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24797 {
24798 PyThreadState* __tstate = wxPyBeginAllowThreads();
24799 wxWakeUpIdle();
24800
24801 wxPyEndAllowThreads(__tstate);
24802 if (PyErr_Occurred()) SWIG_fail;
24803 }
24804 Py_INCREF(Py_None); resultobj = Py_None;
24805 return resultobj;
24806 fail:
24807 return NULL;
24808 }
24809
24810
24811 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24812 PyObject *resultobj = NULL;
24813 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24814 wxEvent *arg2 = 0 ;
24815 PyObject * obj0 = 0 ;
24816 PyObject * obj1 = 0 ;
24817 char *kwnames[] = {
24818 (char *) "dest",(char *) "event", NULL
24819 };
24820
24821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24823 if (SWIG_arg_fail(1)) SWIG_fail;
24824 {
24825 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24826 if (SWIG_arg_fail(2)) SWIG_fail;
24827 if (arg2 == NULL) {
24828 SWIG_null_ref("wxEvent");
24829 }
24830 if (SWIG_arg_fail(2)) SWIG_fail;
24831 }
24832 {
24833 PyThreadState* __tstate = wxPyBeginAllowThreads();
24834 wxPostEvent(arg1,*arg2);
24835
24836 wxPyEndAllowThreads(__tstate);
24837 if (PyErr_Occurred()) SWIG_fail;
24838 }
24839 Py_INCREF(Py_None); resultobj = Py_None;
24840 return resultobj;
24841 fail:
24842 return NULL;
24843 }
24844
24845
24846 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24847 PyObject *resultobj = NULL;
24848 char *kwnames[] = {
24849 NULL
24850 };
24851
24852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24853 {
24854 PyThreadState* __tstate = wxPyBeginAllowThreads();
24855 wxApp_CleanUp();
24856
24857 wxPyEndAllowThreads(__tstate);
24858 if (PyErr_Occurred()) SWIG_fail;
24859 }
24860 Py_INCREF(Py_None); resultobj = Py_None;
24861 return resultobj;
24862 fail:
24863 return NULL;
24864 }
24865
24866
24867 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24868 PyObject *resultobj = NULL;
24869 wxPyApp *result;
24870 char *kwnames[] = {
24871 NULL
24872 };
24873
24874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24875 {
24876 PyThreadState* __tstate = wxPyBeginAllowThreads();
24877 result = (wxPyApp *)wxPyGetApp();
24878
24879 wxPyEndAllowThreads(__tstate);
24880 if (PyErr_Occurred()) SWIG_fail;
24881 }
24882 {
24883 resultobj = wxPyMake_wxObject(result, 0);
24884 }
24885 return resultobj;
24886 fail:
24887 return NULL;
24888 }
24889
24890
24891 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24892 PyObject *resultobj = NULL;
24893 char *arg1 = (char *) 0 ;
24894 PyObject * obj0 = 0 ;
24895 char *kwnames[] = {
24896 (char *) "encoding", NULL
24897 };
24898
24899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24900 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24901 SWIG_arg_fail(1);SWIG_fail;
24902 }
24903 {
24904 PyThreadState* __tstate = wxPyBeginAllowThreads();
24905 wxSetDefaultPyEncoding((char const *)arg1);
24906
24907 wxPyEndAllowThreads(__tstate);
24908 if (PyErr_Occurred()) SWIG_fail;
24909 }
24910 Py_INCREF(Py_None); resultobj = Py_None;
24911 return resultobj;
24912 fail:
24913 return NULL;
24914 }
24915
24916
24917 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24918 PyObject *resultobj = NULL;
24919 char *result;
24920 char *kwnames[] = {
24921 NULL
24922 };
24923
24924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24925 {
24926 PyThreadState* __tstate = wxPyBeginAllowThreads();
24927 result = (char *)wxGetDefaultPyEncoding();
24928
24929 wxPyEndAllowThreads(__tstate);
24930 if (PyErr_Occurred()) SWIG_fail;
24931 }
24932 resultobj = SWIG_FromCharPtr(result);
24933 return resultobj;
24934 fail:
24935 return NULL;
24936 }
24937
24938
24939 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24940 PyObject *resultobj = NULL;
24941 wxEventLoop *result;
24942 char *kwnames[] = {
24943 NULL
24944 };
24945
24946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24947 {
24948 PyThreadState* __tstate = wxPyBeginAllowThreads();
24949 result = (wxEventLoop *)new wxEventLoop();
24950
24951 wxPyEndAllowThreads(__tstate);
24952 if (PyErr_Occurred()) SWIG_fail;
24953 }
24954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24955 return resultobj;
24956 fail:
24957 return NULL;
24958 }
24959
24960
24961 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24962 PyObject *resultobj = NULL;
24963 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24964 PyObject * obj0 = 0 ;
24965 char *kwnames[] = {
24966 (char *) "self", NULL
24967 };
24968
24969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24971 if (SWIG_arg_fail(1)) SWIG_fail;
24972 {
24973 PyThreadState* __tstate = wxPyBeginAllowThreads();
24974 delete arg1;
24975
24976 wxPyEndAllowThreads(__tstate);
24977 if (PyErr_Occurred()) SWIG_fail;
24978 }
24979 Py_INCREF(Py_None); resultobj = Py_None;
24980 return resultobj;
24981 fail:
24982 return NULL;
24983 }
24984
24985
24986 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24987 PyObject *resultobj = NULL;
24988 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24989 int result;
24990 PyObject * obj0 = 0 ;
24991 char *kwnames[] = {
24992 (char *) "self", NULL
24993 };
24994
24995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24997 if (SWIG_arg_fail(1)) SWIG_fail;
24998 {
24999 PyThreadState* __tstate = wxPyBeginAllowThreads();
25000 result = (int)(arg1)->Run();
25001
25002 wxPyEndAllowThreads(__tstate);
25003 if (PyErr_Occurred()) SWIG_fail;
25004 }
25005 {
25006 resultobj = SWIG_From_int(static_cast<int >(result));
25007 }
25008 return resultobj;
25009 fail:
25010 return NULL;
25011 }
25012
25013
25014 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
25015 PyObject *resultobj = NULL;
25016 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25017 int arg2 = (int) 0 ;
25018 PyObject * obj0 = 0 ;
25019 PyObject * obj1 = 0 ;
25020 char *kwnames[] = {
25021 (char *) "self",(char *) "rc", NULL
25022 };
25023
25024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
25025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25026 if (SWIG_arg_fail(1)) SWIG_fail;
25027 if (obj1) {
25028 {
25029 arg2 = static_cast<int >(SWIG_As_int(obj1));
25030 if (SWIG_arg_fail(2)) SWIG_fail;
25031 }
25032 }
25033 {
25034 PyThreadState* __tstate = wxPyBeginAllowThreads();
25035 (arg1)->Exit(arg2);
25036
25037 wxPyEndAllowThreads(__tstate);
25038 if (PyErr_Occurred()) SWIG_fail;
25039 }
25040 Py_INCREF(Py_None); resultobj = Py_None;
25041 return resultobj;
25042 fail:
25043 return NULL;
25044 }
25045
25046
25047 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
25048 PyObject *resultobj = NULL;
25049 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25050 bool result;
25051 PyObject * obj0 = 0 ;
25052 char *kwnames[] = {
25053 (char *) "self", NULL
25054 };
25055
25056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
25057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25058 if (SWIG_arg_fail(1)) SWIG_fail;
25059 {
25060 PyThreadState* __tstate = wxPyBeginAllowThreads();
25061 result = (bool)((wxEventLoop const *)arg1)->Pending();
25062
25063 wxPyEndAllowThreads(__tstate);
25064 if (PyErr_Occurred()) SWIG_fail;
25065 }
25066 {
25067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25068 }
25069 return resultobj;
25070 fail:
25071 return NULL;
25072 }
25073
25074
25075 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
25076 PyObject *resultobj = NULL;
25077 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25078 bool result;
25079 PyObject * obj0 = 0 ;
25080 char *kwnames[] = {
25081 (char *) "self", NULL
25082 };
25083
25084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
25085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25086 if (SWIG_arg_fail(1)) SWIG_fail;
25087 {
25088 PyThreadState* __tstate = wxPyBeginAllowThreads();
25089 result = (bool)(arg1)->Dispatch();
25090
25091 wxPyEndAllowThreads(__tstate);
25092 if (PyErr_Occurred()) SWIG_fail;
25093 }
25094 {
25095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25096 }
25097 return resultobj;
25098 fail:
25099 return NULL;
25100 }
25101
25102
25103 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
25104 PyObject *resultobj = NULL;
25105 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25106 bool result;
25107 PyObject * obj0 = 0 ;
25108 char *kwnames[] = {
25109 (char *) "self", NULL
25110 };
25111
25112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
25113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25114 if (SWIG_arg_fail(1)) SWIG_fail;
25115 {
25116 PyThreadState* __tstate = wxPyBeginAllowThreads();
25117 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
25118
25119 wxPyEndAllowThreads(__tstate);
25120 if (PyErr_Occurred()) SWIG_fail;
25121 }
25122 {
25123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25124 }
25125 return resultobj;
25126 fail:
25127 return NULL;
25128 }
25129
25130
25131 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
25132 PyObject *resultobj = NULL;
25133 wxEventLoop *result;
25134 char *kwnames[] = {
25135 NULL
25136 };
25137
25138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
25139 {
25140 PyThreadState* __tstate = wxPyBeginAllowThreads();
25141 result = (wxEventLoop *)wxEventLoop::GetActive();
25142
25143 wxPyEndAllowThreads(__tstate);
25144 if (PyErr_Occurred()) SWIG_fail;
25145 }
25146 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
25147 return resultobj;
25148 fail:
25149 return NULL;
25150 }
25151
25152
25153 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
25154 PyObject *resultobj = NULL;
25155 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25156 PyObject * obj0 = 0 ;
25157 char *kwnames[] = {
25158 (char *) "loop", NULL
25159 };
25160
25161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
25162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25163 if (SWIG_arg_fail(1)) SWIG_fail;
25164 {
25165 PyThreadState* __tstate = wxPyBeginAllowThreads();
25166 wxEventLoop::SetActive(arg1);
25167
25168 wxPyEndAllowThreads(__tstate);
25169 if (PyErr_Occurred()) SWIG_fail;
25170 }
25171 Py_INCREF(Py_None); resultobj = Py_None;
25172 return resultobj;
25173 fail:
25174 return NULL;
25175 }
25176
25177
25178 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
25179 PyObject *obj;
25180 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25181 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
25182 Py_INCREF(obj);
25183 return Py_BuildValue((char *)"");
25184 }
25185 static PyObject *_wrap_new_EventLoopActivator(PyObject *, PyObject *args, PyObject *kwargs) {
25186 PyObject *resultobj = NULL;
25187 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25188 wxEventLoopActivator *result;
25189 PyObject * obj0 = 0 ;
25190 char *kwnames[] = {
25191 (char *) "evtLoop", NULL
25192 };
25193
25194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) goto fail;
25195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25196 if (SWIG_arg_fail(1)) SWIG_fail;
25197 {
25198 PyThreadState* __tstate = wxPyBeginAllowThreads();
25199 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
25200
25201 wxPyEndAllowThreads(__tstate);
25202 if (PyErr_Occurred()) SWIG_fail;
25203 }
25204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoopActivator, 1);
25205 return resultobj;
25206 fail:
25207 return NULL;
25208 }
25209
25210
25211 static PyObject *_wrap_delete_EventLoopActivator(PyObject *, PyObject *args, PyObject *kwargs) {
25212 PyObject *resultobj = NULL;
25213 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
25214 PyObject * obj0 = 0 ;
25215 char *kwnames[] = {
25216 (char *) "self", NULL
25217 };
25218
25219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoopActivator",kwnames,&obj0)) goto fail;
25220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_EXCEPTION | 0);
25221 if (SWIG_arg_fail(1)) SWIG_fail;
25222 {
25223 PyThreadState* __tstate = wxPyBeginAllowThreads();
25224 delete arg1;
25225
25226 wxPyEndAllowThreads(__tstate);
25227 if (PyErr_Occurred()) SWIG_fail;
25228 }
25229 Py_INCREF(Py_None); resultobj = Py_None;
25230 return resultobj;
25231 fail:
25232 return NULL;
25233 }
25234
25235
25236 static PyObject * EventLoopActivator_swigregister(PyObject *, PyObject *args) {
25237 PyObject *obj;
25238 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25239 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoopActivator, obj);
25240 Py_INCREF(obj);
25241 return Py_BuildValue((char *)"");
25242 }
25243 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25244 PyObject *resultobj = NULL;
25245 int arg1 = (int) 0 ;
25246 int arg2 = (int) 0 ;
25247 int arg3 = (int) 0 ;
25248 wxAcceleratorEntry *result;
25249 PyObject * obj0 = 0 ;
25250 PyObject * obj1 = 0 ;
25251 PyObject * obj2 = 0 ;
25252 char *kwnames[] = {
25253 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
25254 };
25255
25256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
25257 if (obj0) {
25258 {
25259 arg1 = static_cast<int >(SWIG_As_int(obj0));
25260 if (SWIG_arg_fail(1)) SWIG_fail;
25261 }
25262 }
25263 if (obj1) {
25264 {
25265 arg2 = static_cast<int >(SWIG_As_int(obj1));
25266 if (SWIG_arg_fail(2)) SWIG_fail;
25267 }
25268 }
25269 if (obj2) {
25270 {
25271 arg3 = static_cast<int >(SWIG_As_int(obj2));
25272 if (SWIG_arg_fail(3)) SWIG_fail;
25273 }
25274 }
25275 {
25276 PyThreadState* __tstate = wxPyBeginAllowThreads();
25277 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
25278
25279 wxPyEndAllowThreads(__tstate);
25280 if (PyErr_Occurred()) SWIG_fail;
25281 }
25282 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
25283 return resultobj;
25284 fail:
25285 return NULL;
25286 }
25287
25288
25289 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25290 PyObject *resultobj = NULL;
25291 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25292 PyObject * obj0 = 0 ;
25293 char *kwnames[] = {
25294 (char *) "self", NULL
25295 };
25296
25297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
25298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25299 if (SWIG_arg_fail(1)) SWIG_fail;
25300 {
25301 PyThreadState* __tstate = wxPyBeginAllowThreads();
25302 delete arg1;
25303
25304 wxPyEndAllowThreads(__tstate);
25305 if (PyErr_Occurred()) SWIG_fail;
25306 }
25307 Py_INCREF(Py_None); resultobj = Py_None;
25308 return resultobj;
25309 fail:
25310 return NULL;
25311 }
25312
25313
25314 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
25315 PyObject *resultobj = NULL;
25316 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25317 int arg2 ;
25318 int arg3 ;
25319 int arg4 ;
25320 PyObject * obj0 = 0 ;
25321 PyObject * obj1 = 0 ;
25322 PyObject * obj2 = 0 ;
25323 PyObject * obj3 = 0 ;
25324 char *kwnames[] = {
25325 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
25326 };
25327
25328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25330 if (SWIG_arg_fail(1)) SWIG_fail;
25331 {
25332 arg2 = static_cast<int >(SWIG_As_int(obj1));
25333 if (SWIG_arg_fail(2)) SWIG_fail;
25334 }
25335 {
25336 arg3 = static_cast<int >(SWIG_As_int(obj2));
25337 if (SWIG_arg_fail(3)) SWIG_fail;
25338 }
25339 {
25340 arg4 = static_cast<int >(SWIG_As_int(obj3));
25341 if (SWIG_arg_fail(4)) SWIG_fail;
25342 }
25343 {
25344 PyThreadState* __tstate = wxPyBeginAllowThreads();
25345 (arg1)->Set(arg2,arg3,arg4);
25346
25347 wxPyEndAllowThreads(__tstate);
25348 if (PyErr_Occurred()) SWIG_fail;
25349 }
25350 Py_INCREF(Py_None); resultobj = Py_None;
25351 return resultobj;
25352 fail:
25353 return NULL;
25354 }
25355
25356
25357 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
25358 PyObject *resultobj = NULL;
25359 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25360 int result;
25361 PyObject * obj0 = 0 ;
25362 char *kwnames[] = {
25363 (char *) "self", NULL
25364 };
25365
25366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
25367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25368 if (SWIG_arg_fail(1)) SWIG_fail;
25369 {
25370 PyThreadState* __tstate = wxPyBeginAllowThreads();
25371 result = (int)(arg1)->GetFlags();
25372
25373 wxPyEndAllowThreads(__tstate);
25374 if (PyErr_Occurred()) SWIG_fail;
25375 }
25376 {
25377 resultobj = SWIG_From_int(static_cast<int >(result));
25378 }
25379 return resultobj;
25380 fail:
25381 return NULL;
25382 }
25383
25384
25385 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
25386 PyObject *resultobj = NULL;
25387 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25388 int result;
25389 PyObject * obj0 = 0 ;
25390 char *kwnames[] = {
25391 (char *) "self", NULL
25392 };
25393
25394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
25395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25396 if (SWIG_arg_fail(1)) SWIG_fail;
25397 {
25398 PyThreadState* __tstate = wxPyBeginAllowThreads();
25399 result = (int)(arg1)->GetKeyCode();
25400
25401 wxPyEndAllowThreads(__tstate);
25402 if (PyErr_Occurred()) SWIG_fail;
25403 }
25404 {
25405 resultobj = SWIG_From_int(static_cast<int >(result));
25406 }
25407 return resultobj;
25408 fail:
25409 return NULL;
25410 }
25411
25412
25413 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
25414 PyObject *resultobj = NULL;
25415 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25416 int result;
25417 PyObject * obj0 = 0 ;
25418 char *kwnames[] = {
25419 (char *) "self", NULL
25420 };
25421
25422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
25423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25424 if (SWIG_arg_fail(1)) SWIG_fail;
25425 {
25426 PyThreadState* __tstate = wxPyBeginAllowThreads();
25427 result = (int)(arg1)->GetCommand();
25428
25429 wxPyEndAllowThreads(__tstate);
25430 if (PyErr_Occurred()) SWIG_fail;
25431 }
25432 {
25433 resultobj = SWIG_From_int(static_cast<int >(result));
25434 }
25435 return resultobj;
25436 fail:
25437 return NULL;
25438 }
25439
25440
25441 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
25442 PyObject *obj;
25443 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25444 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
25445 Py_INCREF(obj);
25446 return Py_BuildValue((char *)"");
25447 }
25448 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25449 PyObject *resultobj = NULL;
25450 int arg1 ;
25451 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
25452 wxAcceleratorTable *result;
25453 PyObject * obj0 = 0 ;
25454 char *kwnames[] = {
25455 (char *) "n", NULL
25456 };
25457
25458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
25459 {
25460 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
25461 if (arg2) arg1 = PyList_Size(obj0);
25462 else arg1 = 0;
25463 }
25464 {
25465 PyThreadState* __tstate = wxPyBeginAllowThreads();
25466 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
25467
25468 wxPyEndAllowThreads(__tstate);
25469 if (PyErr_Occurred()) SWIG_fail;
25470 }
25471 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
25472 {
25473 delete [] arg2;
25474 }
25475 return resultobj;
25476 fail:
25477 {
25478 delete [] arg2;
25479 }
25480 return NULL;
25481 }
25482
25483
25484 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25485 PyObject *resultobj = NULL;
25486 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25487 PyObject * obj0 = 0 ;
25488 char *kwnames[] = {
25489 (char *) "self", NULL
25490 };
25491
25492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
25493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25494 if (SWIG_arg_fail(1)) SWIG_fail;
25495 {
25496 PyThreadState* __tstate = wxPyBeginAllowThreads();
25497 delete arg1;
25498
25499 wxPyEndAllowThreads(__tstate);
25500 if (PyErr_Occurred()) SWIG_fail;
25501 }
25502 Py_INCREF(Py_None); resultobj = Py_None;
25503 return resultobj;
25504 fail:
25505 return NULL;
25506 }
25507
25508
25509 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
25510 PyObject *resultobj = NULL;
25511 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25512 bool result;
25513 PyObject * obj0 = 0 ;
25514 char *kwnames[] = {
25515 (char *) "self", NULL
25516 };
25517
25518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
25519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25520 if (SWIG_arg_fail(1)) SWIG_fail;
25521 {
25522 PyThreadState* __tstate = wxPyBeginAllowThreads();
25523 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
25524
25525 wxPyEndAllowThreads(__tstate);
25526 if (PyErr_Occurred()) SWIG_fail;
25527 }
25528 {
25529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25530 }
25531 return resultobj;
25532 fail:
25533 return NULL;
25534 }
25535
25536
25537 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
25538 PyObject *obj;
25539 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25540 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
25541 Py_INCREF(obj);
25542 return Py_BuildValue((char *)"");
25543 }
25544 static int _wrap_NullAcceleratorTable_set(PyObject *) {
25545 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
25546 return 1;
25547 }
25548
25549
25550 static PyObject *_wrap_NullAcceleratorTable_get(void) {
25551 PyObject *pyobj = NULL;
25552
25553 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
25554 return pyobj;
25555 }
25556
25557
25558 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
25559 PyObject *resultobj = NULL;
25560 wxString *arg1 = 0 ;
25561 wxAcceleratorEntry *result;
25562 bool temp1 = false ;
25563 PyObject * obj0 = 0 ;
25564 char *kwnames[] = {
25565 (char *) "label", NULL
25566 };
25567
25568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
25569 {
25570 arg1 = wxString_in_helper(obj0);
25571 if (arg1 == NULL) SWIG_fail;
25572 temp1 = true;
25573 }
25574 {
25575 PyThreadState* __tstate = wxPyBeginAllowThreads();
25576 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
25577
25578 wxPyEndAllowThreads(__tstate);
25579 if (PyErr_Occurred()) SWIG_fail;
25580 }
25581 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
25582 {
25583 if (temp1)
25584 delete arg1;
25585 }
25586 return resultobj;
25587 fail:
25588 {
25589 if (temp1)
25590 delete arg1;
25591 }
25592 return NULL;
25593 }
25594
25595
25596 static int _wrap_PanelNameStr_set(PyObject *) {
25597 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
25598 return 1;
25599 }
25600
25601
25602 static PyObject *_wrap_PanelNameStr_get(void) {
25603 PyObject *pyobj = NULL;
25604
25605 {
25606 #if wxUSE_UNICODE
25607 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25608 #else
25609 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25610 #endif
25611 }
25612 return pyobj;
25613 }
25614
25615
25616 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25617 PyObject *resultobj = NULL;
25618 wxVisualAttributes *result;
25619 char *kwnames[] = {
25620 NULL
25621 };
25622
25623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
25624 {
25625 PyThreadState* __tstate = wxPyBeginAllowThreads();
25626 result = (wxVisualAttributes *)new_wxVisualAttributes();
25627
25628 wxPyEndAllowThreads(__tstate);
25629 if (PyErr_Occurred()) SWIG_fail;
25630 }
25631 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
25632 return resultobj;
25633 fail:
25634 return NULL;
25635 }
25636
25637
25638 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25639 PyObject *resultobj = NULL;
25640 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25641 PyObject * obj0 = 0 ;
25642 char *kwnames[] = {
25643 (char *) "self", NULL
25644 };
25645
25646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
25647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25648 if (SWIG_arg_fail(1)) SWIG_fail;
25649 {
25650 PyThreadState* __tstate = wxPyBeginAllowThreads();
25651 delete_wxVisualAttributes(arg1);
25652
25653 wxPyEndAllowThreads(__tstate);
25654 if (PyErr_Occurred()) SWIG_fail;
25655 }
25656 Py_INCREF(Py_None); resultobj = Py_None;
25657 return resultobj;
25658 fail:
25659 return NULL;
25660 }
25661
25662
25663 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
25664 PyObject *resultobj = NULL;
25665 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25666 wxFont *arg2 = (wxFont *) 0 ;
25667 PyObject * obj0 = 0 ;
25668 PyObject * obj1 = 0 ;
25669 char *kwnames[] = {
25670 (char *) "self",(char *) "font", NULL
25671 };
25672
25673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
25674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25675 if (SWIG_arg_fail(1)) SWIG_fail;
25676 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
25677 if (SWIG_arg_fail(2)) SWIG_fail;
25678 if (arg1) (arg1)->font = *arg2;
25679
25680 Py_INCREF(Py_None); resultobj = Py_None;
25681 return resultobj;
25682 fail:
25683 return NULL;
25684 }
25685
25686
25687 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
25688 PyObject *resultobj = NULL;
25689 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25690 wxFont *result;
25691 PyObject * obj0 = 0 ;
25692 char *kwnames[] = {
25693 (char *) "self", NULL
25694 };
25695
25696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
25697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25698 if (SWIG_arg_fail(1)) SWIG_fail;
25699 result = (wxFont *)& ((arg1)->font);
25700
25701 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
25702 return resultobj;
25703 fail:
25704 return NULL;
25705 }
25706
25707
25708 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25709 PyObject *resultobj = NULL;
25710 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25711 wxColour *arg2 = (wxColour *) 0 ;
25712 PyObject * obj0 = 0 ;
25713 PyObject * obj1 = 0 ;
25714 char *kwnames[] = {
25715 (char *) "self",(char *) "colFg", NULL
25716 };
25717
25718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
25719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25720 if (SWIG_arg_fail(1)) SWIG_fail;
25721 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25722 if (SWIG_arg_fail(2)) SWIG_fail;
25723 if (arg1) (arg1)->colFg = *arg2;
25724
25725 Py_INCREF(Py_None); resultobj = Py_None;
25726 return resultobj;
25727 fail:
25728 return NULL;
25729 }
25730
25731
25732 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25733 PyObject *resultobj = NULL;
25734 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25735 wxColour *result;
25736 PyObject * obj0 = 0 ;
25737 char *kwnames[] = {
25738 (char *) "self", NULL
25739 };
25740
25741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
25742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25743 if (SWIG_arg_fail(1)) SWIG_fail;
25744 result = (wxColour *)& ((arg1)->colFg);
25745
25746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25747 return resultobj;
25748 fail:
25749 return NULL;
25750 }
25751
25752
25753 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25754 PyObject *resultobj = NULL;
25755 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25756 wxColour *arg2 = (wxColour *) 0 ;
25757 PyObject * obj0 = 0 ;
25758 PyObject * obj1 = 0 ;
25759 char *kwnames[] = {
25760 (char *) "self",(char *) "colBg", NULL
25761 };
25762
25763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
25764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25765 if (SWIG_arg_fail(1)) SWIG_fail;
25766 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25767 if (SWIG_arg_fail(2)) SWIG_fail;
25768 if (arg1) (arg1)->colBg = *arg2;
25769
25770 Py_INCREF(Py_None); resultobj = Py_None;
25771 return resultobj;
25772 fail:
25773 return NULL;
25774 }
25775
25776
25777 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25778 PyObject *resultobj = NULL;
25779 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25780 wxColour *result;
25781 PyObject * obj0 = 0 ;
25782 char *kwnames[] = {
25783 (char *) "self", NULL
25784 };
25785
25786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
25787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25788 if (SWIG_arg_fail(1)) SWIG_fail;
25789 result = (wxColour *)& ((arg1)->colBg);
25790
25791 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25792 return resultobj;
25793 fail:
25794 return NULL;
25795 }
25796
25797
25798 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
25799 PyObject *obj;
25800 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25801 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
25802 Py_INCREF(obj);
25803 return Py_BuildValue((char *)"");
25804 }
25805 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
25806 PyObject *resultobj = NULL;
25807 wxWindow *arg1 = (wxWindow *) 0 ;
25808 int arg2 = (int) (int)-1 ;
25809 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25810 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25811 wxSize const &arg4_defvalue = wxDefaultSize ;
25812 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25813 long arg5 = (long) 0 ;
25814 wxString const &arg6_defvalue = wxPyPanelNameStr ;
25815 wxString *arg6 = (wxString *) &arg6_defvalue ;
25816 wxWindow *result;
25817 wxPoint temp3 ;
25818 wxSize temp4 ;
25819 bool temp6 = false ;
25820 PyObject * obj0 = 0 ;
25821 PyObject * obj1 = 0 ;
25822 PyObject * obj2 = 0 ;
25823 PyObject * obj3 = 0 ;
25824 PyObject * obj4 = 0 ;
25825 PyObject * obj5 = 0 ;
25826 char *kwnames[] = {
25827 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25828 };
25829
25830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25832 if (SWIG_arg_fail(1)) SWIG_fail;
25833 if (obj1) {
25834 {
25835 arg2 = static_cast<int const >(SWIG_As_int(obj1));
25836 if (SWIG_arg_fail(2)) SWIG_fail;
25837 }
25838 }
25839 if (obj2) {
25840 {
25841 arg3 = &temp3;
25842 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25843 }
25844 }
25845 if (obj3) {
25846 {
25847 arg4 = &temp4;
25848 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25849 }
25850 }
25851 if (obj4) {
25852 {
25853 arg5 = static_cast<long >(SWIG_As_long(obj4));
25854 if (SWIG_arg_fail(5)) SWIG_fail;
25855 }
25856 }
25857 if (obj5) {
25858 {
25859 arg6 = wxString_in_helper(obj5);
25860 if (arg6 == NULL) SWIG_fail;
25861 temp6 = true;
25862 }
25863 }
25864 {
25865 if (!wxPyCheckForApp()) SWIG_fail;
25866 PyThreadState* __tstate = wxPyBeginAllowThreads();
25867 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25868
25869 wxPyEndAllowThreads(__tstate);
25870 if (PyErr_Occurred()) SWIG_fail;
25871 }
25872 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25873 {
25874 if (temp6)
25875 delete arg6;
25876 }
25877 return resultobj;
25878 fail:
25879 {
25880 if (temp6)
25881 delete arg6;
25882 }
25883 return NULL;
25884 }
25885
25886
25887 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25888 PyObject *resultobj = NULL;
25889 wxWindow *result;
25890 char *kwnames[] = {
25891 NULL
25892 };
25893
25894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25895 {
25896 if (!wxPyCheckForApp()) SWIG_fail;
25897 PyThreadState* __tstate = wxPyBeginAllowThreads();
25898 result = (wxWindow *)new wxWindow();
25899
25900 wxPyEndAllowThreads(__tstate);
25901 if (PyErr_Occurred()) SWIG_fail;
25902 }
25903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25904 return resultobj;
25905 fail:
25906 return NULL;
25907 }
25908
25909
25910 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25911 PyObject *resultobj = NULL;
25912 wxWindow *arg1 = (wxWindow *) 0 ;
25913 wxWindow *arg2 = (wxWindow *) 0 ;
25914 int arg3 = (int) (int)-1 ;
25915 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25916 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25917 wxSize const &arg5_defvalue = wxDefaultSize ;
25918 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25919 long arg6 = (long) 0 ;
25920 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25921 wxString *arg7 = (wxString *) &arg7_defvalue ;
25922 bool result;
25923 wxPoint temp4 ;
25924 wxSize temp5 ;
25925 bool temp7 = false ;
25926 PyObject * obj0 = 0 ;
25927 PyObject * obj1 = 0 ;
25928 PyObject * obj2 = 0 ;
25929 PyObject * obj3 = 0 ;
25930 PyObject * obj4 = 0 ;
25931 PyObject * obj5 = 0 ;
25932 PyObject * obj6 = 0 ;
25933 char *kwnames[] = {
25934 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25935 };
25936
25937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25939 if (SWIG_arg_fail(1)) SWIG_fail;
25940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25941 if (SWIG_arg_fail(2)) SWIG_fail;
25942 if (obj2) {
25943 {
25944 arg3 = static_cast<int const >(SWIG_As_int(obj2));
25945 if (SWIG_arg_fail(3)) SWIG_fail;
25946 }
25947 }
25948 if (obj3) {
25949 {
25950 arg4 = &temp4;
25951 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25952 }
25953 }
25954 if (obj4) {
25955 {
25956 arg5 = &temp5;
25957 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25958 }
25959 }
25960 if (obj5) {
25961 {
25962 arg6 = static_cast<long >(SWIG_As_long(obj5));
25963 if (SWIG_arg_fail(6)) SWIG_fail;
25964 }
25965 }
25966 if (obj6) {
25967 {
25968 arg7 = wxString_in_helper(obj6);
25969 if (arg7 == NULL) SWIG_fail;
25970 temp7 = true;
25971 }
25972 }
25973 {
25974 PyThreadState* __tstate = wxPyBeginAllowThreads();
25975 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25976
25977 wxPyEndAllowThreads(__tstate);
25978 if (PyErr_Occurred()) SWIG_fail;
25979 }
25980 {
25981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25982 }
25983 {
25984 if (temp7)
25985 delete arg7;
25986 }
25987 return resultobj;
25988 fail:
25989 {
25990 if (temp7)
25991 delete arg7;
25992 }
25993 return NULL;
25994 }
25995
25996
25997 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25998 PyObject *resultobj = NULL;
25999 wxWindow *arg1 = (wxWindow *) 0 ;
26000 bool arg2 = (bool) false ;
26001 bool result;
26002 PyObject * obj0 = 0 ;
26003 PyObject * obj1 = 0 ;
26004 char *kwnames[] = {
26005 (char *) "self",(char *) "force", NULL
26006 };
26007
26008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
26009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26010 if (SWIG_arg_fail(1)) SWIG_fail;
26011 if (obj1) {
26012 {
26013 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
26014 if (SWIG_arg_fail(2)) SWIG_fail;
26015 }
26016 }
26017 {
26018 PyThreadState* __tstate = wxPyBeginAllowThreads();
26019 result = (bool)(arg1)->Close(arg2);
26020
26021 wxPyEndAllowThreads(__tstate);
26022 if (PyErr_Occurred()) SWIG_fail;
26023 }
26024 {
26025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26026 }
26027 return resultobj;
26028 fail:
26029 return NULL;
26030 }
26031
26032
26033 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
26034 PyObject *resultobj = NULL;
26035 wxWindow *arg1 = (wxWindow *) 0 ;
26036 bool result;
26037 PyObject * obj0 = 0 ;
26038 char *kwnames[] = {
26039 (char *) "self", NULL
26040 };
26041
26042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
26043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26044 if (SWIG_arg_fail(1)) SWIG_fail;
26045 {
26046 PyThreadState* __tstate = wxPyBeginAllowThreads();
26047 result = (bool)(arg1)->Destroy();
26048
26049 wxPyEndAllowThreads(__tstate);
26050 if (PyErr_Occurred()) SWIG_fail;
26051 }
26052 {
26053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26054 }
26055 return resultobj;
26056 fail:
26057 return NULL;
26058 }
26059
26060
26061 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
26062 PyObject *resultobj = NULL;
26063 wxWindow *arg1 = (wxWindow *) 0 ;
26064 bool result;
26065 PyObject * obj0 = 0 ;
26066 char *kwnames[] = {
26067 (char *) "self", NULL
26068 };
26069
26070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
26071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26072 if (SWIG_arg_fail(1)) SWIG_fail;
26073 {
26074 PyThreadState* __tstate = wxPyBeginAllowThreads();
26075 result = (bool)(arg1)->DestroyChildren();
26076
26077 wxPyEndAllowThreads(__tstate);
26078 if (PyErr_Occurred()) SWIG_fail;
26079 }
26080 {
26081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26082 }
26083 return resultobj;
26084 fail:
26085 return NULL;
26086 }
26087
26088
26089 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
26090 PyObject *resultobj = NULL;
26091 wxWindow *arg1 = (wxWindow *) 0 ;
26092 bool result;
26093 PyObject * obj0 = 0 ;
26094 char *kwnames[] = {
26095 (char *) "self", NULL
26096 };
26097
26098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
26099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26100 if (SWIG_arg_fail(1)) SWIG_fail;
26101 {
26102 PyThreadState* __tstate = wxPyBeginAllowThreads();
26103 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
26104
26105 wxPyEndAllowThreads(__tstate);
26106 if (PyErr_Occurred()) SWIG_fail;
26107 }
26108 {
26109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26110 }
26111 return resultobj;
26112 fail:
26113 return NULL;
26114 }
26115
26116
26117 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
26118 PyObject *resultobj = NULL;
26119 wxWindow *arg1 = (wxWindow *) 0 ;
26120 wxString *arg2 = 0 ;
26121 bool temp2 = false ;
26122 PyObject * obj0 = 0 ;
26123 PyObject * obj1 = 0 ;
26124 char *kwnames[] = {
26125 (char *) "self",(char *) "label", NULL
26126 };
26127
26128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
26129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26130 if (SWIG_arg_fail(1)) SWIG_fail;
26131 {
26132 arg2 = wxString_in_helper(obj1);
26133 if (arg2 == NULL) SWIG_fail;
26134 temp2 = true;
26135 }
26136 {
26137 PyThreadState* __tstate = wxPyBeginAllowThreads();
26138 (arg1)->SetLabel((wxString const &)*arg2);
26139
26140 wxPyEndAllowThreads(__tstate);
26141 if (PyErr_Occurred()) SWIG_fail;
26142 }
26143 Py_INCREF(Py_None); resultobj = Py_None;
26144 {
26145 if (temp2)
26146 delete arg2;
26147 }
26148 return resultobj;
26149 fail:
26150 {
26151 if (temp2)
26152 delete arg2;
26153 }
26154 return NULL;
26155 }
26156
26157
26158 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
26159 PyObject *resultobj = NULL;
26160 wxWindow *arg1 = (wxWindow *) 0 ;
26161 wxString result;
26162 PyObject * obj0 = 0 ;
26163 char *kwnames[] = {
26164 (char *) "self", NULL
26165 };
26166
26167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
26168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26169 if (SWIG_arg_fail(1)) SWIG_fail;
26170 {
26171 PyThreadState* __tstate = wxPyBeginAllowThreads();
26172 result = ((wxWindow const *)arg1)->GetLabel();
26173
26174 wxPyEndAllowThreads(__tstate);
26175 if (PyErr_Occurred()) SWIG_fail;
26176 }
26177 {
26178 #if wxUSE_UNICODE
26179 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26180 #else
26181 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26182 #endif
26183 }
26184 return resultobj;
26185 fail:
26186 return NULL;
26187 }
26188
26189
26190 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
26191 PyObject *resultobj = NULL;
26192 wxWindow *arg1 = (wxWindow *) 0 ;
26193 wxString *arg2 = 0 ;
26194 bool temp2 = false ;
26195 PyObject * obj0 = 0 ;
26196 PyObject * obj1 = 0 ;
26197 char *kwnames[] = {
26198 (char *) "self",(char *) "name", NULL
26199 };
26200
26201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
26202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26203 if (SWIG_arg_fail(1)) SWIG_fail;
26204 {
26205 arg2 = wxString_in_helper(obj1);
26206 if (arg2 == NULL) SWIG_fail;
26207 temp2 = true;
26208 }
26209 {
26210 PyThreadState* __tstate = wxPyBeginAllowThreads();
26211 (arg1)->SetName((wxString const &)*arg2);
26212
26213 wxPyEndAllowThreads(__tstate);
26214 if (PyErr_Occurred()) SWIG_fail;
26215 }
26216 Py_INCREF(Py_None); resultobj = Py_None;
26217 {
26218 if (temp2)
26219 delete arg2;
26220 }
26221 return resultobj;
26222 fail:
26223 {
26224 if (temp2)
26225 delete arg2;
26226 }
26227 return NULL;
26228 }
26229
26230
26231 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
26232 PyObject *resultobj = NULL;
26233 wxWindow *arg1 = (wxWindow *) 0 ;
26234 wxString result;
26235 PyObject * obj0 = 0 ;
26236 char *kwnames[] = {
26237 (char *) "self", NULL
26238 };
26239
26240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
26241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26242 if (SWIG_arg_fail(1)) SWIG_fail;
26243 {
26244 PyThreadState* __tstate = wxPyBeginAllowThreads();
26245 result = ((wxWindow const *)arg1)->GetName();
26246
26247 wxPyEndAllowThreads(__tstate);
26248 if (PyErr_Occurred()) SWIG_fail;
26249 }
26250 {
26251 #if wxUSE_UNICODE
26252 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26253 #else
26254 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26255 #endif
26256 }
26257 return resultobj;
26258 fail:
26259 return NULL;
26260 }
26261
26262
26263 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26264 PyObject *resultobj = NULL;
26265 wxWindow *arg1 = (wxWindow *) 0 ;
26266 wxWindowVariant arg2 ;
26267 PyObject * obj0 = 0 ;
26268 PyObject * obj1 = 0 ;
26269 char *kwnames[] = {
26270 (char *) "self",(char *) "variant", NULL
26271 };
26272
26273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
26274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26275 if (SWIG_arg_fail(1)) SWIG_fail;
26276 {
26277 arg2 = static_cast<wxWindowVariant >(SWIG_As_int(obj1));
26278 if (SWIG_arg_fail(2)) SWIG_fail;
26279 }
26280 {
26281 PyThreadState* __tstate = wxPyBeginAllowThreads();
26282 (arg1)->SetWindowVariant(arg2);
26283
26284 wxPyEndAllowThreads(__tstate);
26285 if (PyErr_Occurred()) SWIG_fail;
26286 }
26287 Py_INCREF(Py_None); resultobj = Py_None;
26288 return resultobj;
26289 fail:
26290 return NULL;
26291 }
26292
26293
26294 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26295 PyObject *resultobj = NULL;
26296 wxWindow *arg1 = (wxWindow *) 0 ;
26297 wxWindowVariant result;
26298 PyObject * obj0 = 0 ;
26299 char *kwnames[] = {
26300 (char *) "self", NULL
26301 };
26302
26303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
26304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26305 if (SWIG_arg_fail(1)) SWIG_fail;
26306 {
26307 PyThreadState* __tstate = wxPyBeginAllowThreads();
26308 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
26309
26310 wxPyEndAllowThreads(__tstate);
26311 if (PyErr_Occurred()) SWIG_fail;
26312 }
26313 resultobj = SWIG_From_int((result));
26314 return resultobj;
26315 fail:
26316 return NULL;
26317 }
26318
26319
26320 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26321 PyObject *resultobj = NULL;
26322 wxWindow *arg1 = (wxWindow *) 0 ;
26323 int arg2 ;
26324 PyObject * obj0 = 0 ;
26325 PyObject * obj1 = 0 ;
26326 char *kwnames[] = {
26327 (char *) "self",(char *) "winid", NULL
26328 };
26329
26330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
26331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26332 if (SWIG_arg_fail(1)) SWIG_fail;
26333 {
26334 arg2 = static_cast<int >(SWIG_As_int(obj1));
26335 if (SWIG_arg_fail(2)) SWIG_fail;
26336 }
26337 {
26338 PyThreadState* __tstate = wxPyBeginAllowThreads();
26339 (arg1)->SetId(arg2);
26340
26341 wxPyEndAllowThreads(__tstate);
26342 if (PyErr_Occurred()) SWIG_fail;
26343 }
26344 Py_INCREF(Py_None); resultobj = Py_None;
26345 return resultobj;
26346 fail:
26347 return NULL;
26348 }
26349
26350
26351 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26352 PyObject *resultobj = NULL;
26353 wxWindow *arg1 = (wxWindow *) 0 ;
26354 int result;
26355 PyObject * obj0 = 0 ;
26356 char *kwnames[] = {
26357 (char *) "self", NULL
26358 };
26359
26360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
26361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26362 if (SWIG_arg_fail(1)) SWIG_fail;
26363 {
26364 PyThreadState* __tstate = wxPyBeginAllowThreads();
26365 result = (int)((wxWindow const *)arg1)->GetId();
26366
26367 wxPyEndAllowThreads(__tstate);
26368 if (PyErr_Occurred()) SWIG_fail;
26369 }
26370 {
26371 resultobj = SWIG_From_int(static_cast<int >(result));
26372 }
26373 return resultobj;
26374 fail:
26375 return NULL;
26376 }
26377
26378
26379 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26380 PyObject *resultobj = NULL;
26381 int result;
26382 char *kwnames[] = {
26383 NULL
26384 };
26385
26386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
26387 {
26388 PyThreadState* __tstate = wxPyBeginAllowThreads();
26389 result = (int)wxWindow::NewControlId();
26390
26391 wxPyEndAllowThreads(__tstate);
26392 if (PyErr_Occurred()) SWIG_fail;
26393 }
26394 {
26395 resultobj = SWIG_From_int(static_cast<int >(result));
26396 }
26397 return resultobj;
26398 fail:
26399 return NULL;
26400 }
26401
26402
26403 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26404 PyObject *resultobj = NULL;
26405 int arg1 ;
26406 int result;
26407 PyObject * obj0 = 0 ;
26408 char *kwnames[] = {
26409 (char *) "winid", NULL
26410 };
26411
26412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
26413 {
26414 arg1 = static_cast<int >(SWIG_As_int(obj0));
26415 if (SWIG_arg_fail(1)) SWIG_fail;
26416 }
26417 {
26418 PyThreadState* __tstate = wxPyBeginAllowThreads();
26419 result = (int)wxWindow::NextControlId(arg1);
26420
26421 wxPyEndAllowThreads(__tstate);
26422 if (PyErr_Occurred()) SWIG_fail;
26423 }
26424 {
26425 resultobj = SWIG_From_int(static_cast<int >(result));
26426 }
26427 return resultobj;
26428 fail:
26429 return NULL;
26430 }
26431
26432
26433 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26434 PyObject *resultobj = NULL;
26435 int arg1 ;
26436 int result;
26437 PyObject * obj0 = 0 ;
26438 char *kwnames[] = {
26439 (char *) "winid", NULL
26440 };
26441
26442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
26443 {
26444 arg1 = static_cast<int >(SWIG_As_int(obj0));
26445 if (SWIG_arg_fail(1)) SWIG_fail;
26446 }
26447 {
26448 PyThreadState* __tstate = wxPyBeginAllowThreads();
26449 result = (int)wxWindow::PrevControlId(arg1);
26450
26451 wxPyEndAllowThreads(__tstate);
26452 if (PyErr_Occurred()) SWIG_fail;
26453 }
26454 {
26455 resultobj = SWIG_From_int(static_cast<int >(result));
26456 }
26457 return resultobj;
26458 fail:
26459 return NULL;
26460 }
26461
26462
26463 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26464 PyObject *resultobj = NULL;
26465 wxWindow *arg1 = (wxWindow *) 0 ;
26466 wxSize *arg2 = 0 ;
26467 wxSize temp2 ;
26468 PyObject * obj0 = 0 ;
26469 PyObject * obj1 = 0 ;
26470 char *kwnames[] = {
26471 (char *) "self",(char *) "size", NULL
26472 };
26473
26474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
26475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26476 if (SWIG_arg_fail(1)) SWIG_fail;
26477 {
26478 arg2 = &temp2;
26479 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26480 }
26481 {
26482 PyThreadState* __tstate = wxPyBeginAllowThreads();
26483 (arg1)->SetSize((wxSize const &)*arg2);
26484
26485 wxPyEndAllowThreads(__tstate);
26486 if (PyErr_Occurred()) SWIG_fail;
26487 }
26488 Py_INCREF(Py_None); resultobj = Py_None;
26489 return resultobj;
26490 fail:
26491 return NULL;
26492 }
26493
26494
26495 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
26496 PyObject *resultobj = NULL;
26497 wxWindow *arg1 = (wxWindow *) 0 ;
26498 int arg2 ;
26499 int arg3 ;
26500 int arg4 ;
26501 int arg5 ;
26502 int arg6 = (int) wxSIZE_AUTO ;
26503 PyObject * obj0 = 0 ;
26504 PyObject * obj1 = 0 ;
26505 PyObject * obj2 = 0 ;
26506 PyObject * obj3 = 0 ;
26507 PyObject * obj4 = 0 ;
26508 PyObject * obj5 = 0 ;
26509 char *kwnames[] = {
26510 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
26511 };
26512
26513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
26514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26515 if (SWIG_arg_fail(1)) SWIG_fail;
26516 {
26517 arg2 = static_cast<int >(SWIG_As_int(obj1));
26518 if (SWIG_arg_fail(2)) SWIG_fail;
26519 }
26520 {
26521 arg3 = static_cast<int >(SWIG_As_int(obj2));
26522 if (SWIG_arg_fail(3)) SWIG_fail;
26523 }
26524 {
26525 arg4 = static_cast<int >(SWIG_As_int(obj3));
26526 if (SWIG_arg_fail(4)) SWIG_fail;
26527 }
26528 {
26529 arg5 = static_cast<int >(SWIG_As_int(obj4));
26530 if (SWIG_arg_fail(5)) SWIG_fail;
26531 }
26532 if (obj5) {
26533 {
26534 arg6 = static_cast<int >(SWIG_As_int(obj5));
26535 if (SWIG_arg_fail(6)) SWIG_fail;
26536 }
26537 }
26538 {
26539 PyThreadState* __tstate = wxPyBeginAllowThreads();
26540 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
26541
26542 wxPyEndAllowThreads(__tstate);
26543 if (PyErr_Occurred()) SWIG_fail;
26544 }
26545 Py_INCREF(Py_None); resultobj = Py_None;
26546 return resultobj;
26547 fail:
26548 return NULL;
26549 }
26550
26551
26552 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26553 PyObject *resultobj = NULL;
26554 wxWindow *arg1 = (wxWindow *) 0 ;
26555 wxRect *arg2 = 0 ;
26556 int arg3 = (int) wxSIZE_AUTO ;
26557 wxRect temp2 ;
26558 PyObject * obj0 = 0 ;
26559 PyObject * obj1 = 0 ;
26560 PyObject * obj2 = 0 ;
26561 char *kwnames[] = {
26562 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
26563 };
26564
26565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
26566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26567 if (SWIG_arg_fail(1)) SWIG_fail;
26568 {
26569 arg2 = &temp2;
26570 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26571 }
26572 if (obj2) {
26573 {
26574 arg3 = static_cast<int >(SWIG_As_int(obj2));
26575 if (SWIG_arg_fail(3)) SWIG_fail;
26576 }
26577 }
26578 {
26579 PyThreadState* __tstate = wxPyBeginAllowThreads();
26580 (arg1)->SetSize((wxRect const &)*arg2,arg3);
26581
26582 wxPyEndAllowThreads(__tstate);
26583 if (PyErr_Occurred()) SWIG_fail;
26584 }
26585 Py_INCREF(Py_None); resultobj = Py_None;
26586 return resultobj;
26587 fail:
26588 return NULL;
26589 }
26590
26591
26592 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26593 PyObject *resultobj = NULL;
26594 wxWindow *arg1 = (wxWindow *) 0 ;
26595 int arg2 ;
26596 int arg3 ;
26597 PyObject * obj0 = 0 ;
26598 PyObject * obj1 = 0 ;
26599 PyObject * obj2 = 0 ;
26600 char *kwnames[] = {
26601 (char *) "self",(char *) "width",(char *) "height", NULL
26602 };
26603
26604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26606 if (SWIG_arg_fail(1)) SWIG_fail;
26607 {
26608 arg2 = static_cast<int >(SWIG_As_int(obj1));
26609 if (SWIG_arg_fail(2)) SWIG_fail;
26610 }
26611 {
26612 arg3 = static_cast<int >(SWIG_As_int(obj2));
26613 if (SWIG_arg_fail(3)) SWIG_fail;
26614 }
26615 {
26616 PyThreadState* __tstate = wxPyBeginAllowThreads();
26617 (arg1)->SetSize(arg2,arg3);
26618
26619 wxPyEndAllowThreads(__tstate);
26620 if (PyErr_Occurred()) SWIG_fail;
26621 }
26622 Py_INCREF(Py_None); resultobj = Py_None;
26623 return resultobj;
26624 fail:
26625 return NULL;
26626 }
26627
26628
26629 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
26630 PyObject *resultobj = NULL;
26631 wxWindow *arg1 = (wxWindow *) 0 ;
26632 wxPoint *arg2 = 0 ;
26633 int arg3 = (int) wxSIZE_USE_EXISTING ;
26634 wxPoint temp2 ;
26635 PyObject * obj0 = 0 ;
26636 PyObject * obj1 = 0 ;
26637 PyObject * obj2 = 0 ;
26638 char *kwnames[] = {
26639 (char *) "self",(char *) "pt",(char *) "flags", NULL
26640 };
26641
26642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
26643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26644 if (SWIG_arg_fail(1)) SWIG_fail;
26645 {
26646 arg2 = &temp2;
26647 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26648 }
26649 if (obj2) {
26650 {
26651 arg3 = static_cast<int >(SWIG_As_int(obj2));
26652 if (SWIG_arg_fail(3)) SWIG_fail;
26653 }
26654 }
26655 {
26656 PyThreadState* __tstate = wxPyBeginAllowThreads();
26657 (arg1)->Move((wxPoint const &)*arg2,arg3);
26658
26659 wxPyEndAllowThreads(__tstate);
26660 if (PyErr_Occurred()) SWIG_fail;
26661 }
26662 Py_INCREF(Py_None); resultobj = Py_None;
26663 return resultobj;
26664 fail:
26665 return NULL;
26666 }
26667
26668
26669 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
26670 PyObject *resultobj = NULL;
26671 wxWindow *arg1 = (wxWindow *) 0 ;
26672 int arg2 ;
26673 int arg3 ;
26674 int arg4 = (int) wxSIZE_USE_EXISTING ;
26675 PyObject * obj0 = 0 ;
26676 PyObject * obj1 = 0 ;
26677 PyObject * obj2 = 0 ;
26678 PyObject * obj3 = 0 ;
26679 char *kwnames[] = {
26680 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
26681 };
26682
26683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26685 if (SWIG_arg_fail(1)) SWIG_fail;
26686 {
26687 arg2 = static_cast<int >(SWIG_As_int(obj1));
26688 if (SWIG_arg_fail(2)) SWIG_fail;
26689 }
26690 {
26691 arg3 = static_cast<int >(SWIG_As_int(obj2));
26692 if (SWIG_arg_fail(3)) SWIG_fail;
26693 }
26694 if (obj3) {
26695 {
26696 arg4 = static_cast<int >(SWIG_As_int(obj3));
26697 if (SWIG_arg_fail(4)) SWIG_fail;
26698 }
26699 }
26700 {
26701 PyThreadState* __tstate = wxPyBeginAllowThreads();
26702 (arg1)->Move(arg2,arg3,arg4);
26703
26704 wxPyEndAllowThreads(__tstate);
26705 if (PyErr_Occurred()) SWIG_fail;
26706 }
26707 Py_INCREF(Py_None); resultobj = Py_None;
26708 return resultobj;
26709 fail:
26710 return NULL;
26711 }
26712
26713
26714 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26715 PyObject *resultobj = NULL;
26716 wxWindow *arg1 = (wxWindow *) 0 ;
26717 wxSize const &arg2_defvalue = wxDefaultSize ;
26718 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
26719 wxSize temp2 ;
26720 PyObject * obj0 = 0 ;
26721 PyObject * obj1 = 0 ;
26722 char *kwnames[] = {
26723 (char *) "self",(char *) "size", NULL
26724 };
26725
26726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
26727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26728 if (SWIG_arg_fail(1)) SWIG_fail;
26729 if (obj1) {
26730 {
26731 arg2 = &temp2;
26732 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26733 }
26734 }
26735 {
26736 PyThreadState* __tstate = wxPyBeginAllowThreads();
26737 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
26738
26739 wxPyEndAllowThreads(__tstate);
26740 if (PyErr_Occurred()) SWIG_fail;
26741 }
26742 Py_INCREF(Py_None); resultobj = Py_None;
26743 return resultobj;
26744 fail:
26745 return NULL;
26746 }
26747
26748
26749 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26750 PyObject *resultobj = NULL;
26751 wxWindow *arg1 = (wxWindow *) 0 ;
26752 PyObject * obj0 = 0 ;
26753 char *kwnames[] = {
26754 (char *) "self", NULL
26755 };
26756
26757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26759 if (SWIG_arg_fail(1)) SWIG_fail;
26760 {
26761 PyThreadState* __tstate = wxPyBeginAllowThreads();
26762 (arg1)->Raise();
26763
26764 wxPyEndAllowThreads(__tstate);
26765 if (PyErr_Occurred()) SWIG_fail;
26766 }
26767 Py_INCREF(Py_None); resultobj = Py_None;
26768 return resultobj;
26769 fail:
26770 return NULL;
26771 }
26772
26773
26774 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26775 PyObject *resultobj = NULL;
26776 wxWindow *arg1 = (wxWindow *) 0 ;
26777 PyObject * obj0 = 0 ;
26778 char *kwnames[] = {
26779 (char *) "self", NULL
26780 };
26781
26782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26784 if (SWIG_arg_fail(1)) SWIG_fail;
26785 {
26786 PyThreadState* __tstate = wxPyBeginAllowThreads();
26787 (arg1)->Lower();
26788
26789 wxPyEndAllowThreads(__tstate);
26790 if (PyErr_Occurred()) SWIG_fail;
26791 }
26792 Py_INCREF(Py_None); resultobj = Py_None;
26793 return resultobj;
26794 fail:
26795 return NULL;
26796 }
26797
26798
26799 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26800 PyObject *resultobj = NULL;
26801 wxWindow *arg1 = (wxWindow *) 0 ;
26802 wxSize *arg2 = 0 ;
26803 wxSize temp2 ;
26804 PyObject * obj0 = 0 ;
26805 PyObject * obj1 = 0 ;
26806 char *kwnames[] = {
26807 (char *) "self",(char *) "size", NULL
26808 };
26809
26810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26812 if (SWIG_arg_fail(1)) SWIG_fail;
26813 {
26814 arg2 = &temp2;
26815 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26816 }
26817 {
26818 PyThreadState* __tstate = wxPyBeginAllowThreads();
26819 (arg1)->SetClientSize((wxSize const &)*arg2);
26820
26821 wxPyEndAllowThreads(__tstate);
26822 if (PyErr_Occurred()) SWIG_fail;
26823 }
26824 Py_INCREF(Py_None); resultobj = Py_None;
26825 return resultobj;
26826 fail:
26827 return NULL;
26828 }
26829
26830
26831 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26832 PyObject *resultobj = NULL;
26833 wxWindow *arg1 = (wxWindow *) 0 ;
26834 int arg2 ;
26835 int arg3 ;
26836 PyObject * obj0 = 0 ;
26837 PyObject * obj1 = 0 ;
26838 PyObject * obj2 = 0 ;
26839 char *kwnames[] = {
26840 (char *) "self",(char *) "width",(char *) "height", NULL
26841 };
26842
26843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26845 if (SWIG_arg_fail(1)) SWIG_fail;
26846 {
26847 arg2 = static_cast<int >(SWIG_As_int(obj1));
26848 if (SWIG_arg_fail(2)) SWIG_fail;
26849 }
26850 {
26851 arg3 = static_cast<int >(SWIG_As_int(obj2));
26852 if (SWIG_arg_fail(3)) SWIG_fail;
26853 }
26854 {
26855 PyThreadState* __tstate = wxPyBeginAllowThreads();
26856 (arg1)->SetClientSize(arg2,arg3);
26857
26858 wxPyEndAllowThreads(__tstate);
26859 if (PyErr_Occurred()) SWIG_fail;
26860 }
26861 Py_INCREF(Py_None); resultobj = Py_None;
26862 return resultobj;
26863 fail:
26864 return NULL;
26865 }
26866
26867
26868 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26869 PyObject *resultobj = NULL;
26870 wxWindow *arg1 = (wxWindow *) 0 ;
26871 wxRect *arg2 = 0 ;
26872 wxRect temp2 ;
26873 PyObject * obj0 = 0 ;
26874 PyObject * obj1 = 0 ;
26875 char *kwnames[] = {
26876 (char *) "self",(char *) "rect", NULL
26877 };
26878
26879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26881 if (SWIG_arg_fail(1)) SWIG_fail;
26882 {
26883 arg2 = &temp2;
26884 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26885 }
26886 {
26887 PyThreadState* __tstate = wxPyBeginAllowThreads();
26888 (arg1)->SetClientSize((wxRect const &)*arg2);
26889
26890 wxPyEndAllowThreads(__tstate);
26891 if (PyErr_Occurred()) SWIG_fail;
26892 }
26893 Py_INCREF(Py_None); resultobj = Py_None;
26894 return resultobj;
26895 fail:
26896 return NULL;
26897 }
26898
26899
26900 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26901 PyObject *resultobj = NULL;
26902 wxWindow *arg1 = (wxWindow *) 0 ;
26903 wxPoint result;
26904 PyObject * obj0 = 0 ;
26905 char *kwnames[] = {
26906 (char *) "self", NULL
26907 };
26908
26909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26911 if (SWIG_arg_fail(1)) SWIG_fail;
26912 {
26913 PyThreadState* __tstate = wxPyBeginAllowThreads();
26914 result = (arg1)->GetPosition();
26915
26916 wxPyEndAllowThreads(__tstate);
26917 if (PyErr_Occurred()) SWIG_fail;
26918 }
26919 {
26920 wxPoint * resultptr;
26921 resultptr = new wxPoint(static_cast<wxPoint & >(result));
26922 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26923 }
26924 return resultobj;
26925 fail:
26926 return NULL;
26927 }
26928
26929
26930 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26931 PyObject *resultobj = NULL;
26932 wxWindow *arg1 = (wxWindow *) 0 ;
26933 int *arg2 = (int *) 0 ;
26934 int *arg3 = (int *) 0 ;
26935 int temp2 ;
26936 int res2 = 0 ;
26937 int temp3 ;
26938 int res3 = 0 ;
26939 PyObject * obj0 = 0 ;
26940 char *kwnames[] = {
26941 (char *) "self", NULL
26942 };
26943
26944 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26945 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26948 if (SWIG_arg_fail(1)) SWIG_fail;
26949 {
26950 PyThreadState* __tstate = wxPyBeginAllowThreads();
26951 (arg1)->GetPosition(arg2,arg3);
26952
26953 wxPyEndAllowThreads(__tstate);
26954 if (PyErr_Occurred()) SWIG_fail;
26955 }
26956 Py_INCREF(Py_None); resultobj = Py_None;
26957 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26958 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26959 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26960 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26961 return resultobj;
26962 fail:
26963 return NULL;
26964 }
26965
26966
26967 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26968 PyObject *resultobj = NULL;
26969 wxWindow *arg1 = (wxWindow *) 0 ;
26970 wxSize result;
26971 PyObject * obj0 = 0 ;
26972 char *kwnames[] = {
26973 (char *) "self", NULL
26974 };
26975
26976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26978 if (SWIG_arg_fail(1)) SWIG_fail;
26979 {
26980 PyThreadState* __tstate = wxPyBeginAllowThreads();
26981 result = ((wxWindow const *)arg1)->GetSize();
26982
26983 wxPyEndAllowThreads(__tstate);
26984 if (PyErr_Occurred()) SWIG_fail;
26985 }
26986 {
26987 wxSize * resultptr;
26988 resultptr = new wxSize(static_cast<wxSize & >(result));
26989 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26990 }
26991 return resultobj;
26992 fail:
26993 return NULL;
26994 }
26995
26996
26997 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26998 PyObject *resultobj = NULL;
26999 wxWindow *arg1 = (wxWindow *) 0 ;
27000 int *arg2 = (int *) 0 ;
27001 int *arg3 = (int *) 0 ;
27002 int temp2 ;
27003 int res2 = 0 ;
27004 int temp3 ;
27005 int res3 = 0 ;
27006 PyObject * obj0 = 0 ;
27007 char *kwnames[] = {
27008 (char *) "self", NULL
27009 };
27010
27011 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27012 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
27014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27015 if (SWIG_arg_fail(1)) SWIG_fail;
27016 {
27017 PyThreadState* __tstate = wxPyBeginAllowThreads();
27018 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
27019
27020 wxPyEndAllowThreads(__tstate);
27021 if (PyErr_Occurred()) SWIG_fail;
27022 }
27023 Py_INCREF(Py_None); resultobj = Py_None;
27024 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27025 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27026 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27027 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27028 return resultobj;
27029 fail:
27030 return NULL;
27031 }
27032
27033
27034 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
27035 PyObject *resultobj = NULL;
27036 wxWindow *arg1 = (wxWindow *) 0 ;
27037 wxRect result;
27038 PyObject * obj0 = 0 ;
27039 char *kwnames[] = {
27040 (char *) "self", NULL
27041 };
27042
27043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
27044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27045 if (SWIG_arg_fail(1)) SWIG_fail;
27046 {
27047 PyThreadState* __tstate = wxPyBeginAllowThreads();
27048 result = ((wxWindow const *)arg1)->GetRect();
27049
27050 wxPyEndAllowThreads(__tstate);
27051 if (PyErr_Occurred()) SWIG_fail;
27052 }
27053 {
27054 wxRect * resultptr;
27055 resultptr = new wxRect(static_cast<wxRect & >(result));
27056 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
27057 }
27058 return resultobj;
27059 fail:
27060 return NULL;
27061 }
27062
27063
27064 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
27065 PyObject *resultobj = NULL;
27066 wxWindow *arg1 = (wxWindow *) 0 ;
27067 wxSize result;
27068 PyObject * obj0 = 0 ;
27069 char *kwnames[] = {
27070 (char *) "self", NULL
27071 };
27072
27073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
27074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27075 if (SWIG_arg_fail(1)) SWIG_fail;
27076 {
27077 PyThreadState* __tstate = wxPyBeginAllowThreads();
27078 result = ((wxWindow const *)arg1)->GetClientSize();
27079
27080 wxPyEndAllowThreads(__tstate);
27081 if (PyErr_Occurred()) SWIG_fail;
27082 }
27083 {
27084 wxSize * resultptr;
27085 resultptr = new wxSize(static_cast<wxSize & >(result));
27086 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27087 }
27088 return resultobj;
27089 fail:
27090 return NULL;
27091 }
27092
27093
27094 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27095 PyObject *resultobj = NULL;
27096 wxWindow *arg1 = (wxWindow *) 0 ;
27097 int *arg2 = (int *) 0 ;
27098 int *arg3 = (int *) 0 ;
27099 int temp2 ;
27100 int res2 = 0 ;
27101 int temp3 ;
27102 int res3 = 0 ;
27103 PyObject * obj0 = 0 ;
27104 char *kwnames[] = {
27105 (char *) "self", NULL
27106 };
27107
27108 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27109 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
27111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27112 if (SWIG_arg_fail(1)) SWIG_fail;
27113 {
27114 PyThreadState* __tstate = wxPyBeginAllowThreads();
27115 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
27116
27117 wxPyEndAllowThreads(__tstate);
27118 if (PyErr_Occurred()) SWIG_fail;
27119 }
27120 Py_INCREF(Py_None); resultobj = Py_None;
27121 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27122 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27123 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27124 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27125 return resultobj;
27126 fail:
27127 return NULL;
27128 }
27129
27130
27131 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
27132 PyObject *resultobj = NULL;
27133 wxWindow *arg1 = (wxWindow *) 0 ;
27134 wxPoint result;
27135 PyObject * obj0 = 0 ;
27136 char *kwnames[] = {
27137 (char *) "self", NULL
27138 };
27139
27140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
27141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27142 if (SWIG_arg_fail(1)) SWIG_fail;
27143 {
27144 PyThreadState* __tstate = wxPyBeginAllowThreads();
27145 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
27146
27147 wxPyEndAllowThreads(__tstate);
27148 if (PyErr_Occurred()) SWIG_fail;
27149 }
27150 {
27151 wxPoint * resultptr;
27152 resultptr = new wxPoint(static_cast<wxPoint & >(result));
27153 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
27154 }
27155 return resultobj;
27156 fail:
27157 return NULL;
27158 }
27159
27160
27161 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
27162 PyObject *resultobj = NULL;
27163 wxWindow *arg1 = (wxWindow *) 0 ;
27164 wxRect result;
27165 PyObject * obj0 = 0 ;
27166 char *kwnames[] = {
27167 (char *) "self", NULL
27168 };
27169
27170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
27171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27172 if (SWIG_arg_fail(1)) SWIG_fail;
27173 {
27174 PyThreadState* __tstate = wxPyBeginAllowThreads();
27175 result = ((wxWindow const *)arg1)->GetClientRect();
27176
27177 wxPyEndAllowThreads(__tstate);
27178 if (PyErr_Occurred()) SWIG_fail;
27179 }
27180 {
27181 wxRect * resultptr;
27182 resultptr = new wxRect(static_cast<wxRect & >(result));
27183 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
27184 }
27185 return resultobj;
27186 fail:
27187 return NULL;
27188 }
27189
27190
27191 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27192 PyObject *resultobj = NULL;
27193 wxWindow *arg1 = (wxWindow *) 0 ;
27194 wxSize result;
27195 PyObject * obj0 = 0 ;
27196 char *kwnames[] = {
27197 (char *) "self", NULL
27198 };
27199
27200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
27201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27202 if (SWIG_arg_fail(1)) SWIG_fail;
27203 {
27204 PyThreadState* __tstate = wxPyBeginAllowThreads();
27205 result = ((wxWindow const *)arg1)->GetBestSize();
27206
27207 wxPyEndAllowThreads(__tstate);
27208 if (PyErr_Occurred()) SWIG_fail;
27209 }
27210 {
27211 wxSize * resultptr;
27212 resultptr = new wxSize(static_cast<wxSize & >(result));
27213 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27214 }
27215 return resultobj;
27216 fail:
27217 return NULL;
27218 }
27219
27220
27221 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27222 PyObject *resultobj = NULL;
27223 wxWindow *arg1 = (wxWindow *) 0 ;
27224 int *arg2 = (int *) 0 ;
27225 int *arg3 = (int *) 0 ;
27226 int temp2 ;
27227 int res2 = 0 ;
27228 int temp3 ;
27229 int res3 = 0 ;
27230 PyObject * obj0 = 0 ;
27231 char *kwnames[] = {
27232 (char *) "self", NULL
27233 };
27234
27235 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27236 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
27238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27239 if (SWIG_arg_fail(1)) SWIG_fail;
27240 {
27241 PyThreadState* __tstate = wxPyBeginAllowThreads();
27242 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
27243
27244 wxPyEndAllowThreads(__tstate);
27245 if (PyErr_Occurred()) SWIG_fail;
27246 }
27247 Py_INCREF(Py_None); resultobj = Py_None;
27248 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27249 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27250 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27251 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27252 return resultobj;
27253 fail:
27254 return NULL;
27255 }
27256
27257
27258 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27259 PyObject *resultobj = NULL;
27260 wxWindow *arg1 = (wxWindow *) 0 ;
27261 PyObject * obj0 = 0 ;
27262 char *kwnames[] = {
27263 (char *) "self", NULL
27264 };
27265
27266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
27267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27268 if (SWIG_arg_fail(1)) SWIG_fail;
27269 {
27270 PyThreadState* __tstate = wxPyBeginAllowThreads();
27271 (arg1)->InvalidateBestSize();
27272
27273 wxPyEndAllowThreads(__tstate);
27274 if (PyErr_Occurred()) SWIG_fail;
27275 }
27276 Py_INCREF(Py_None); resultobj = Py_None;
27277 return resultobj;
27278 fail:
27279 return NULL;
27280 }
27281
27282
27283 static PyObject *_wrap_Window_CacheBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27284 PyObject *resultobj = NULL;
27285 wxWindow *arg1 = (wxWindow *) 0 ;
27286 wxSize *arg2 = 0 ;
27287 wxSize temp2 ;
27288 PyObject * obj0 = 0 ;
27289 PyObject * obj1 = 0 ;
27290 char *kwnames[] = {
27291 (char *) "self",(char *) "size", NULL
27292 };
27293
27294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) goto fail;
27295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27296 if (SWIG_arg_fail(1)) SWIG_fail;
27297 {
27298 arg2 = &temp2;
27299 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27300 }
27301 {
27302 PyThreadState* __tstate = wxPyBeginAllowThreads();
27303 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
27304
27305 wxPyEndAllowThreads(__tstate);
27306 if (PyErr_Occurred()) SWIG_fail;
27307 }
27308 Py_INCREF(Py_None); resultobj = Py_None;
27309 return resultobj;
27310 fail:
27311 return NULL;
27312 }
27313
27314
27315 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
27316 PyObject *resultobj = NULL;
27317 wxWindow *arg1 = (wxWindow *) 0 ;
27318 wxSize result;
27319 PyObject * obj0 = 0 ;
27320 char *kwnames[] = {
27321 (char *) "self", NULL
27322 };
27323
27324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
27325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27326 if (SWIG_arg_fail(1)) SWIG_fail;
27327 {
27328 PyThreadState* __tstate = wxPyBeginAllowThreads();
27329 result = ((wxWindow const *)arg1)->GetBestFittingSize();
27330
27331 wxPyEndAllowThreads(__tstate);
27332 if (PyErr_Occurred()) SWIG_fail;
27333 }
27334 {
27335 wxSize * resultptr;
27336 resultptr = new wxSize(static_cast<wxSize & >(result));
27337 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27338 }
27339 return resultobj;
27340 fail:
27341 return NULL;
27342 }
27343
27344
27345 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27346 PyObject *resultobj = NULL;
27347 wxWindow *arg1 = (wxWindow *) 0 ;
27348 wxSize result;
27349 PyObject * obj0 = 0 ;
27350 char *kwnames[] = {
27351 (char *) "self", NULL
27352 };
27353
27354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
27355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27356 if (SWIG_arg_fail(1)) SWIG_fail;
27357 {
27358 PyThreadState* __tstate = wxPyBeginAllowThreads();
27359 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
27360
27361 wxPyEndAllowThreads(__tstate);
27362 if (PyErr_Occurred()) SWIG_fail;
27363 }
27364 {
27365 wxSize * resultptr;
27366 resultptr = new wxSize(static_cast<wxSize & >(result));
27367 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27368 }
27369 return resultobj;
27370 fail:
27371 return NULL;
27372 }
27373
27374
27375 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
27376 PyObject *resultobj = NULL;
27377 wxWindow *arg1 = (wxWindow *) 0 ;
27378 int arg2 = (int) wxBOTH ;
27379 PyObject * obj0 = 0 ;
27380 PyObject * obj1 = 0 ;
27381 char *kwnames[] = {
27382 (char *) "self",(char *) "direction", NULL
27383 };
27384
27385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
27386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27387 if (SWIG_arg_fail(1)) SWIG_fail;
27388 if (obj1) {
27389 {
27390 arg2 = static_cast<int >(SWIG_As_int(obj1));
27391 if (SWIG_arg_fail(2)) SWIG_fail;
27392 }
27393 }
27394 {
27395 PyThreadState* __tstate = wxPyBeginAllowThreads();
27396 (arg1)->Center(arg2);
27397
27398 wxPyEndAllowThreads(__tstate);
27399 if (PyErr_Occurred()) SWIG_fail;
27400 }
27401 Py_INCREF(Py_None); resultobj = Py_None;
27402 return resultobj;
27403 fail:
27404 return NULL;
27405 }
27406
27407
27408 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
27409 PyObject *resultobj = NULL;
27410 wxWindow *arg1 = (wxWindow *) 0 ;
27411 int arg2 = (int) wxBOTH ;
27412 PyObject * obj0 = 0 ;
27413 PyObject * obj1 = 0 ;
27414 char *kwnames[] = {
27415 (char *) "self",(char *) "dir", NULL
27416 };
27417
27418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
27419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27420 if (SWIG_arg_fail(1)) SWIG_fail;
27421 if (obj1) {
27422 {
27423 arg2 = static_cast<int >(SWIG_As_int(obj1));
27424 if (SWIG_arg_fail(2)) SWIG_fail;
27425 }
27426 }
27427 {
27428 PyThreadState* __tstate = wxPyBeginAllowThreads();
27429 (arg1)->CenterOnScreen(arg2);
27430
27431 wxPyEndAllowThreads(__tstate);
27432 if (PyErr_Occurred()) SWIG_fail;
27433 }
27434 Py_INCREF(Py_None); resultobj = Py_None;
27435 return resultobj;
27436 fail:
27437 return NULL;
27438 }
27439
27440
27441 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
27442 PyObject *resultobj = NULL;
27443 wxWindow *arg1 = (wxWindow *) 0 ;
27444 int arg2 = (int) wxBOTH ;
27445 PyObject * obj0 = 0 ;
27446 PyObject * obj1 = 0 ;
27447 char *kwnames[] = {
27448 (char *) "self",(char *) "dir", NULL
27449 };
27450
27451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
27452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27453 if (SWIG_arg_fail(1)) SWIG_fail;
27454 if (obj1) {
27455 {
27456 arg2 = static_cast<int >(SWIG_As_int(obj1));
27457 if (SWIG_arg_fail(2)) SWIG_fail;
27458 }
27459 }
27460 {
27461 PyThreadState* __tstate = wxPyBeginAllowThreads();
27462 (arg1)->CenterOnParent(arg2);
27463
27464 wxPyEndAllowThreads(__tstate);
27465 if (PyErr_Occurred()) SWIG_fail;
27466 }
27467 Py_INCREF(Py_None); resultobj = Py_None;
27468 return resultobj;
27469 fail:
27470 return NULL;
27471 }
27472
27473
27474 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
27475 PyObject *resultobj = NULL;
27476 wxWindow *arg1 = (wxWindow *) 0 ;
27477 PyObject * obj0 = 0 ;
27478 char *kwnames[] = {
27479 (char *) "self", NULL
27480 };
27481
27482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
27483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27484 if (SWIG_arg_fail(1)) SWIG_fail;
27485 {
27486 PyThreadState* __tstate = wxPyBeginAllowThreads();
27487 (arg1)->Fit();
27488
27489 wxPyEndAllowThreads(__tstate);
27490 if (PyErr_Occurred()) SWIG_fail;
27491 }
27492 Py_INCREF(Py_None); resultobj = Py_None;
27493 return resultobj;
27494 fail:
27495 return NULL;
27496 }
27497
27498
27499 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
27500 PyObject *resultobj = NULL;
27501 wxWindow *arg1 = (wxWindow *) 0 ;
27502 PyObject * obj0 = 0 ;
27503 char *kwnames[] = {
27504 (char *) "self", NULL
27505 };
27506
27507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
27508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27509 if (SWIG_arg_fail(1)) SWIG_fail;
27510 {
27511 PyThreadState* __tstate = wxPyBeginAllowThreads();
27512 (arg1)->FitInside();
27513
27514 wxPyEndAllowThreads(__tstate);
27515 if (PyErr_Occurred()) SWIG_fail;
27516 }
27517 Py_INCREF(Py_None); resultobj = Py_None;
27518 return resultobj;
27519 fail:
27520 return NULL;
27521 }
27522
27523
27524 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27525 PyObject *resultobj = NULL;
27526 wxWindow *arg1 = (wxWindow *) 0 ;
27527 int arg2 ;
27528 int arg3 ;
27529 int arg4 = (int) -1 ;
27530 int arg5 = (int) -1 ;
27531 int arg6 = (int) -1 ;
27532 int arg7 = (int) -1 ;
27533 PyObject * obj0 = 0 ;
27534 PyObject * obj1 = 0 ;
27535 PyObject * obj2 = 0 ;
27536 PyObject * obj3 = 0 ;
27537 PyObject * obj4 = 0 ;
27538 PyObject * obj5 = 0 ;
27539 PyObject * obj6 = 0 ;
27540 char *kwnames[] = {
27541 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
27542 };
27543
27544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27546 if (SWIG_arg_fail(1)) SWIG_fail;
27547 {
27548 arg2 = static_cast<int >(SWIG_As_int(obj1));
27549 if (SWIG_arg_fail(2)) SWIG_fail;
27550 }
27551 {
27552 arg3 = static_cast<int >(SWIG_As_int(obj2));
27553 if (SWIG_arg_fail(3)) SWIG_fail;
27554 }
27555 if (obj3) {
27556 {
27557 arg4 = static_cast<int >(SWIG_As_int(obj3));
27558 if (SWIG_arg_fail(4)) SWIG_fail;
27559 }
27560 }
27561 if (obj4) {
27562 {
27563 arg5 = static_cast<int >(SWIG_As_int(obj4));
27564 if (SWIG_arg_fail(5)) SWIG_fail;
27565 }
27566 }
27567 if (obj5) {
27568 {
27569 arg6 = static_cast<int >(SWIG_As_int(obj5));
27570 if (SWIG_arg_fail(6)) SWIG_fail;
27571 }
27572 }
27573 if (obj6) {
27574 {
27575 arg7 = static_cast<int >(SWIG_As_int(obj6));
27576 if (SWIG_arg_fail(7)) SWIG_fail;
27577 }
27578 }
27579 {
27580 PyThreadState* __tstate = wxPyBeginAllowThreads();
27581 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
27582
27583 wxPyEndAllowThreads(__tstate);
27584 if (PyErr_Occurred()) SWIG_fail;
27585 }
27586 Py_INCREF(Py_None); resultobj = Py_None;
27587 return resultobj;
27588 fail:
27589 return NULL;
27590 }
27591
27592
27593 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27594 PyObject *resultobj = NULL;
27595 wxWindow *arg1 = (wxWindow *) 0 ;
27596 wxSize *arg2 = 0 ;
27597 wxSize const &arg3_defvalue = wxDefaultSize ;
27598 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27599 wxSize const &arg4_defvalue = wxDefaultSize ;
27600 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
27601 wxSize temp2 ;
27602 wxSize temp3 ;
27603 wxSize temp4 ;
27604 PyObject * obj0 = 0 ;
27605 PyObject * obj1 = 0 ;
27606 PyObject * obj2 = 0 ;
27607 PyObject * obj3 = 0 ;
27608 char *kwnames[] = {
27609 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
27610 };
27611
27612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
27613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27614 if (SWIG_arg_fail(1)) SWIG_fail;
27615 {
27616 arg2 = &temp2;
27617 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27618 }
27619 if (obj2) {
27620 {
27621 arg3 = &temp3;
27622 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27623 }
27624 }
27625 if (obj3) {
27626 {
27627 arg4 = &temp4;
27628 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
27629 }
27630 }
27631 {
27632 PyThreadState* __tstate = wxPyBeginAllowThreads();
27633 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
27634
27635 wxPyEndAllowThreads(__tstate);
27636 if (PyErr_Occurred()) SWIG_fail;
27637 }
27638 Py_INCREF(Py_None); resultobj = Py_None;
27639 return resultobj;
27640 fail:
27641 return NULL;
27642 }
27643
27644
27645 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27646 PyObject *resultobj = NULL;
27647 wxWindow *arg1 = (wxWindow *) 0 ;
27648 int arg2 ;
27649 int arg3 ;
27650 int arg4 = (int) -1 ;
27651 int arg5 = (int) -1 ;
27652 PyObject * obj0 = 0 ;
27653 PyObject * obj1 = 0 ;
27654 PyObject * obj2 = 0 ;
27655 PyObject * obj3 = 0 ;
27656 PyObject * obj4 = 0 ;
27657 char *kwnames[] = {
27658 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
27659 };
27660
27661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
27662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27663 if (SWIG_arg_fail(1)) SWIG_fail;
27664 {
27665 arg2 = static_cast<int >(SWIG_As_int(obj1));
27666 if (SWIG_arg_fail(2)) SWIG_fail;
27667 }
27668 {
27669 arg3 = static_cast<int >(SWIG_As_int(obj2));
27670 if (SWIG_arg_fail(3)) SWIG_fail;
27671 }
27672 if (obj3) {
27673 {
27674 arg4 = static_cast<int >(SWIG_As_int(obj3));
27675 if (SWIG_arg_fail(4)) SWIG_fail;
27676 }
27677 }
27678 if (obj4) {
27679 {
27680 arg5 = static_cast<int >(SWIG_As_int(obj4));
27681 if (SWIG_arg_fail(5)) SWIG_fail;
27682 }
27683 }
27684 {
27685 PyThreadState* __tstate = wxPyBeginAllowThreads();
27686 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
27687
27688 wxPyEndAllowThreads(__tstate);
27689 if (PyErr_Occurred()) SWIG_fail;
27690 }
27691 Py_INCREF(Py_None); resultobj = Py_None;
27692 return resultobj;
27693 fail:
27694 return NULL;
27695 }
27696
27697
27698 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27699 PyObject *resultobj = NULL;
27700 wxWindow *arg1 = (wxWindow *) 0 ;
27701 wxSize *arg2 = 0 ;
27702 wxSize const &arg3_defvalue = wxDefaultSize ;
27703 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27704 wxSize temp2 ;
27705 wxSize temp3 ;
27706 PyObject * obj0 = 0 ;
27707 PyObject * obj1 = 0 ;
27708 PyObject * obj2 = 0 ;
27709 char *kwnames[] = {
27710 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
27711 };
27712
27713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
27714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27715 if (SWIG_arg_fail(1)) SWIG_fail;
27716 {
27717 arg2 = &temp2;
27718 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27719 }
27720 if (obj2) {
27721 {
27722 arg3 = &temp3;
27723 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27724 }
27725 }
27726 {
27727 PyThreadState* __tstate = wxPyBeginAllowThreads();
27728 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
27729
27730 wxPyEndAllowThreads(__tstate);
27731 if (PyErr_Occurred()) SWIG_fail;
27732 }
27733 Py_INCREF(Py_None); resultobj = Py_None;
27734 return resultobj;
27735 fail:
27736 return NULL;
27737 }
27738
27739
27740 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27741 PyObject *resultobj = NULL;
27742 wxWindow *arg1 = (wxWindow *) 0 ;
27743 wxSize result;
27744 PyObject * obj0 = 0 ;
27745 char *kwnames[] = {
27746 (char *) "self", NULL
27747 };
27748
27749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
27750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27751 if (SWIG_arg_fail(1)) SWIG_fail;
27752 {
27753 PyThreadState* __tstate = wxPyBeginAllowThreads();
27754 result = ((wxWindow const *)arg1)->GetMaxSize();
27755
27756 wxPyEndAllowThreads(__tstate);
27757 if (PyErr_Occurred()) SWIG_fail;
27758 }
27759 {
27760 wxSize * resultptr;
27761 resultptr = new wxSize(static_cast<wxSize & >(result));
27762 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27763 }
27764 return resultobj;
27765 fail:
27766 return NULL;
27767 }
27768
27769
27770 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27771 PyObject *resultobj = NULL;
27772 wxWindow *arg1 = (wxWindow *) 0 ;
27773 wxSize result;
27774 PyObject * obj0 = 0 ;
27775 char *kwnames[] = {
27776 (char *) "self", NULL
27777 };
27778
27779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27781 if (SWIG_arg_fail(1)) SWIG_fail;
27782 {
27783 PyThreadState* __tstate = wxPyBeginAllowThreads();
27784 result = ((wxWindow const *)arg1)->GetMinSize();
27785
27786 wxPyEndAllowThreads(__tstate);
27787 if (PyErr_Occurred()) SWIG_fail;
27788 }
27789 {
27790 wxSize * resultptr;
27791 resultptr = new wxSize(static_cast<wxSize & >(result));
27792 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27793 }
27794 return resultobj;
27795 fail:
27796 return NULL;
27797 }
27798
27799
27800 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27801 PyObject *resultobj = NULL;
27802 wxWindow *arg1 = (wxWindow *) 0 ;
27803 wxSize *arg2 = 0 ;
27804 wxSize temp2 ;
27805 PyObject * obj0 = 0 ;
27806 PyObject * obj1 = 0 ;
27807 char *kwnames[] = {
27808 (char *) "self",(char *) "minSize", NULL
27809 };
27810
27811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27813 if (SWIG_arg_fail(1)) SWIG_fail;
27814 {
27815 arg2 = &temp2;
27816 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27817 }
27818 {
27819 PyThreadState* __tstate = wxPyBeginAllowThreads();
27820 (arg1)->SetMinSize((wxSize const &)*arg2);
27821
27822 wxPyEndAllowThreads(__tstate);
27823 if (PyErr_Occurred()) SWIG_fail;
27824 }
27825 Py_INCREF(Py_None); resultobj = Py_None;
27826 return resultobj;
27827 fail:
27828 return NULL;
27829 }
27830
27831
27832 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27833 PyObject *resultobj = NULL;
27834 wxWindow *arg1 = (wxWindow *) 0 ;
27835 wxSize *arg2 = 0 ;
27836 wxSize temp2 ;
27837 PyObject * obj0 = 0 ;
27838 PyObject * obj1 = 0 ;
27839 char *kwnames[] = {
27840 (char *) "self",(char *) "maxSize", NULL
27841 };
27842
27843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27845 if (SWIG_arg_fail(1)) SWIG_fail;
27846 {
27847 arg2 = &temp2;
27848 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27849 }
27850 {
27851 PyThreadState* __tstate = wxPyBeginAllowThreads();
27852 (arg1)->SetMaxSize((wxSize const &)*arg2);
27853
27854 wxPyEndAllowThreads(__tstate);
27855 if (PyErr_Occurred()) SWIG_fail;
27856 }
27857 Py_INCREF(Py_None); resultobj = Py_None;
27858 return resultobj;
27859 fail:
27860 return NULL;
27861 }
27862
27863
27864 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27865 PyObject *resultobj = NULL;
27866 wxWindow *arg1 = (wxWindow *) 0 ;
27867 int result;
27868 PyObject * obj0 = 0 ;
27869 char *kwnames[] = {
27870 (char *) "self", NULL
27871 };
27872
27873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27875 if (SWIG_arg_fail(1)) SWIG_fail;
27876 {
27877 PyThreadState* __tstate = wxPyBeginAllowThreads();
27878 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27879
27880 wxPyEndAllowThreads(__tstate);
27881 if (PyErr_Occurred()) SWIG_fail;
27882 }
27883 {
27884 resultobj = SWIG_From_int(static_cast<int >(result));
27885 }
27886 return resultobj;
27887 fail:
27888 return NULL;
27889 }
27890
27891
27892 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27893 PyObject *resultobj = NULL;
27894 wxWindow *arg1 = (wxWindow *) 0 ;
27895 int result;
27896 PyObject * obj0 = 0 ;
27897 char *kwnames[] = {
27898 (char *) "self", NULL
27899 };
27900
27901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27903 if (SWIG_arg_fail(1)) SWIG_fail;
27904 {
27905 PyThreadState* __tstate = wxPyBeginAllowThreads();
27906 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27907
27908 wxPyEndAllowThreads(__tstate);
27909 if (PyErr_Occurred()) SWIG_fail;
27910 }
27911 {
27912 resultobj = SWIG_From_int(static_cast<int >(result));
27913 }
27914 return resultobj;
27915 fail:
27916 return NULL;
27917 }
27918
27919
27920 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27921 PyObject *resultobj = NULL;
27922 wxWindow *arg1 = (wxWindow *) 0 ;
27923 int result;
27924 PyObject * obj0 = 0 ;
27925 char *kwnames[] = {
27926 (char *) "self", NULL
27927 };
27928
27929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27931 if (SWIG_arg_fail(1)) SWIG_fail;
27932 {
27933 PyThreadState* __tstate = wxPyBeginAllowThreads();
27934 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27935
27936 wxPyEndAllowThreads(__tstate);
27937 if (PyErr_Occurred()) SWIG_fail;
27938 }
27939 {
27940 resultobj = SWIG_From_int(static_cast<int >(result));
27941 }
27942 return resultobj;
27943 fail:
27944 return NULL;
27945 }
27946
27947
27948 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27949 PyObject *resultobj = NULL;
27950 wxWindow *arg1 = (wxWindow *) 0 ;
27951 int result;
27952 PyObject * obj0 = 0 ;
27953 char *kwnames[] = {
27954 (char *) "self", NULL
27955 };
27956
27957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27959 if (SWIG_arg_fail(1)) SWIG_fail;
27960 {
27961 PyThreadState* __tstate = wxPyBeginAllowThreads();
27962 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27963
27964 wxPyEndAllowThreads(__tstate);
27965 if (PyErr_Occurred()) SWIG_fail;
27966 }
27967 {
27968 resultobj = SWIG_From_int(static_cast<int >(result));
27969 }
27970 return resultobj;
27971 fail:
27972 return NULL;
27973 }
27974
27975
27976 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27977 PyObject *resultobj = NULL;
27978 wxWindow *arg1 = (wxWindow *) 0 ;
27979 wxSize *arg2 = 0 ;
27980 wxSize temp2 ;
27981 PyObject * obj0 = 0 ;
27982 PyObject * obj1 = 0 ;
27983 char *kwnames[] = {
27984 (char *) "self",(char *) "size", NULL
27985 };
27986
27987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27989 if (SWIG_arg_fail(1)) SWIG_fail;
27990 {
27991 arg2 = &temp2;
27992 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27993 }
27994 {
27995 PyThreadState* __tstate = wxPyBeginAllowThreads();
27996 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27997
27998 wxPyEndAllowThreads(__tstate);
27999 if (PyErr_Occurred()) SWIG_fail;
28000 }
28001 Py_INCREF(Py_None); resultobj = Py_None;
28002 return resultobj;
28003 fail:
28004 return NULL;
28005 }
28006
28007
28008 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
28009 PyObject *resultobj = NULL;
28010 wxWindow *arg1 = (wxWindow *) 0 ;
28011 int arg2 ;
28012 int arg3 ;
28013 PyObject * obj0 = 0 ;
28014 PyObject * obj1 = 0 ;
28015 PyObject * obj2 = 0 ;
28016 char *kwnames[] = {
28017 (char *) "self",(char *) "w",(char *) "h", NULL
28018 };
28019
28020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
28021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28022 if (SWIG_arg_fail(1)) SWIG_fail;
28023 {
28024 arg2 = static_cast<int >(SWIG_As_int(obj1));
28025 if (SWIG_arg_fail(2)) SWIG_fail;
28026 }
28027 {
28028 arg3 = static_cast<int >(SWIG_As_int(obj2));
28029 if (SWIG_arg_fail(3)) SWIG_fail;
28030 }
28031 {
28032 PyThreadState* __tstate = wxPyBeginAllowThreads();
28033 (arg1)->SetVirtualSize(arg2,arg3);
28034
28035 wxPyEndAllowThreads(__tstate);
28036 if (PyErr_Occurred()) SWIG_fail;
28037 }
28038 Py_INCREF(Py_None); resultobj = Py_None;
28039 return resultobj;
28040 fail:
28041 return NULL;
28042 }
28043
28044
28045 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28046 PyObject *resultobj = NULL;
28047 wxWindow *arg1 = (wxWindow *) 0 ;
28048 wxSize result;
28049 PyObject * obj0 = 0 ;
28050 char *kwnames[] = {
28051 (char *) "self", NULL
28052 };
28053
28054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
28055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28056 if (SWIG_arg_fail(1)) SWIG_fail;
28057 {
28058 PyThreadState* __tstate = wxPyBeginAllowThreads();
28059 result = ((wxWindow const *)arg1)->GetVirtualSize();
28060
28061 wxPyEndAllowThreads(__tstate);
28062 if (PyErr_Occurred()) SWIG_fail;
28063 }
28064 {
28065 wxSize * resultptr;
28066 resultptr = new wxSize(static_cast<wxSize & >(result));
28067 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28068 }
28069 return resultobj;
28070 fail:
28071 return NULL;
28072 }
28073
28074
28075 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
28076 PyObject *resultobj = NULL;
28077 wxWindow *arg1 = (wxWindow *) 0 ;
28078 int *arg2 = (int *) 0 ;
28079 int *arg3 = (int *) 0 ;
28080 int temp2 ;
28081 int res2 = 0 ;
28082 int temp3 ;
28083 int res3 = 0 ;
28084 PyObject * obj0 = 0 ;
28085 char *kwnames[] = {
28086 (char *) "self", NULL
28087 };
28088
28089 arg2 = &temp2; res2 = SWIG_NEWOBJ;
28090 arg3 = &temp3; res3 = SWIG_NEWOBJ;
28091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
28092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28093 if (SWIG_arg_fail(1)) SWIG_fail;
28094 {
28095 PyThreadState* __tstate = wxPyBeginAllowThreads();
28096 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
28097
28098 wxPyEndAllowThreads(__tstate);
28099 if (PyErr_Occurred()) SWIG_fail;
28100 }
28101 Py_INCREF(Py_None); resultobj = Py_None;
28102 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
28103 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
28104 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
28105 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
28106 return resultobj;
28107 fail:
28108 return NULL;
28109 }
28110
28111
28112 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28113 PyObject *resultobj = NULL;
28114 wxWindow *arg1 = (wxWindow *) 0 ;
28115 wxSize result;
28116 PyObject * obj0 = 0 ;
28117 char *kwnames[] = {
28118 (char *) "self", NULL
28119 };
28120
28121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
28122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28123 if (SWIG_arg_fail(1)) SWIG_fail;
28124 {
28125 PyThreadState* __tstate = wxPyBeginAllowThreads();
28126 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
28127
28128 wxPyEndAllowThreads(__tstate);
28129 if (PyErr_Occurred()) SWIG_fail;
28130 }
28131 {
28132 wxSize * resultptr;
28133 resultptr = new wxSize(static_cast<wxSize & >(result));
28134 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28135 }
28136 return resultobj;
28137 fail:
28138 return NULL;
28139 }
28140
28141
28142 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
28143 PyObject *resultobj = NULL;
28144 wxWindow *arg1 = (wxWindow *) 0 ;
28145 bool arg2 = (bool) true ;
28146 bool result;
28147 PyObject * obj0 = 0 ;
28148 PyObject * obj1 = 0 ;
28149 char *kwnames[] = {
28150 (char *) "self",(char *) "show", NULL
28151 };
28152
28153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
28154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28155 if (SWIG_arg_fail(1)) SWIG_fail;
28156 if (obj1) {
28157 {
28158 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28159 if (SWIG_arg_fail(2)) SWIG_fail;
28160 }
28161 }
28162 {
28163 PyThreadState* __tstate = wxPyBeginAllowThreads();
28164 result = (bool)(arg1)->Show(arg2);
28165
28166 wxPyEndAllowThreads(__tstate);
28167 if (PyErr_Occurred()) SWIG_fail;
28168 }
28169 {
28170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28171 }
28172 return resultobj;
28173 fail:
28174 return NULL;
28175 }
28176
28177
28178 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
28179 PyObject *resultobj = NULL;
28180 wxWindow *arg1 = (wxWindow *) 0 ;
28181 bool result;
28182 PyObject * obj0 = 0 ;
28183 char *kwnames[] = {
28184 (char *) "self", NULL
28185 };
28186
28187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
28188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28189 if (SWIG_arg_fail(1)) SWIG_fail;
28190 {
28191 PyThreadState* __tstate = wxPyBeginAllowThreads();
28192 result = (bool)(arg1)->Hide();
28193
28194 wxPyEndAllowThreads(__tstate);
28195 if (PyErr_Occurred()) SWIG_fail;
28196 }
28197 {
28198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28199 }
28200 return resultobj;
28201 fail:
28202 return NULL;
28203 }
28204
28205
28206 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
28207 PyObject *resultobj = NULL;
28208 wxWindow *arg1 = (wxWindow *) 0 ;
28209 bool arg2 = (bool) true ;
28210 bool result;
28211 PyObject * obj0 = 0 ;
28212 PyObject * obj1 = 0 ;
28213 char *kwnames[] = {
28214 (char *) "self",(char *) "enable", NULL
28215 };
28216
28217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
28218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28219 if (SWIG_arg_fail(1)) SWIG_fail;
28220 if (obj1) {
28221 {
28222 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28223 if (SWIG_arg_fail(2)) SWIG_fail;
28224 }
28225 }
28226 {
28227 PyThreadState* __tstate = wxPyBeginAllowThreads();
28228 result = (bool)(arg1)->Enable(arg2);
28229
28230 wxPyEndAllowThreads(__tstate);
28231 if (PyErr_Occurred()) SWIG_fail;
28232 }
28233 {
28234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28235 }
28236 return resultobj;
28237 fail:
28238 return NULL;
28239 }
28240
28241
28242 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
28243 PyObject *resultobj = NULL;
28244 wxWindow *arg1 = (wxWindow *) 0 ;
28245 bool result;
28246 PyObject * obj0 = 0 ;
28247 char *kwnames[] = {
28248 (char *) "self", NULL
28249 };
28250
28251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
28252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28253 if (SWIG_arg_fail(1)) SWIG_fail;
28254 {
28255 PyThreadState* __tstate = wxPyBeginAllowThreads();
28256 result = (bool)(arg1)->Disable();
28257
28258 wxPyEndAllowThreads(__tstate);
28259 if (PyErr_Occurred()) SWIG_fail;
28260 }
28261 {
28262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28263 }
28264 return resultobj;
28265 fail:
28266 return NULL;
28267 }
28268
28269
28270 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
28271 PyObject *resultobj = NULL;
28272 wxWindow *arg1 = (wxWindow *) 0 ;
28273 bool result;
28274 PyObject * obj0 = 0 ;
28275 char *kwnames[] = {
28276 (char *) "self", NULL
28277 };
28278
28279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
28280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28281 if (SWIG_arg_fail(1)) SWIG_fail;
28282 {
28283 PyThreadState* __tstate = wxPyBeginAllowThreads();
28284 result = (bool)((wxWindow const *)arg1)->IsShown();
28285
28286 wxPyEndAllowThreads(__tstate);
28287 if (PyErr_Occurred()) SWIG_fail;
28288 }
28289 {
28290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28291 }
28292 return resultobj;
28293 fail:
28294 return NULL;
28295 }
28296
28297
28298 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28299 PyObject *resultobj = NULL;
28300 wxWindow *arg1 = (wxWindow *) 0 ;
28301 bool result;
28302 PyObject * obj0 = 0 ;
28303 char *kwnames[] = {
28304 (char *) "self", NULL
28305 };
28306
28307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
28308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28309 if (SWIG_arg_fail(1)) SWIG_fail;
28310 {
28311 PyThreadState* __tstate = wxPyBeginAllowThreads();
28312 result = (bool)((wxWindow const *)arg1)->IsEnabled();
28313
28314 wxPyEndAllowThreads(__tstate);
28315 if (PyErr_Occurred()) SWIG_fail;
28316 }
28317 {
28318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28319 }
28320 return resultobj;
28321 fail:
28322 return NULL;
28323 }
28324
28325
28326 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28327 PyObject *resultobj = NULL;
28328 wxWindow *arg1 = (wxWindow *) 0 ;
28329 long arg2 ;
28330 PyObject * obj0 = 0 ;
28331 PyObject * obj1 = 0 ;
28332 char *kwnames[] = {
28333 (char *) "self",(char *) "style", NULL
28334 };
28335
28336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
28337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28338 if (SWIG_arg_fail(1)) SWIG_fail;
28339 {
28340 arg2 = static_cast<long >(SWIG_As_long(obj1));
28341 if (SWIG_arg_fail(2)) SWIG_fail;
28342 }
28343 {
28344 PyThreadState* __tstate = wxPyBeginAllowThreads();
28345 (arg1)->SetWindowStyleFlag(arg2);
28346
28347 wxPyEndAllowThreads(__tstate);
28348 if (PyErr_Occurred()) SWIG_fail;
28349 }
28350 Py_INCREF(Py_None); resultobj = Py_None;
28351 return resultobj;
28352 fail:
28353 return NULL;
28354 }
28355
28356
28357 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28358 PyObject *resultobj = NULL;
28359 wxWindow *arg1 = (wxWindow *) 0 ;
28360 long result;
28361 PyObject * obj0 = 0 ;
28362 char *kwnames[] = {
28363 (char *) "self", NULL
28364 };
28365
28366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
28367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28368 if (SWIG_arg_fail(1)) SWIG_fail;
28369 {
28370 PyThreadState* __tstate = wxPyBeginAllowThreads();
28371 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
28372
28373 wxPyEndAllowThreads(__tstate);
28374 if (PyErr_Occurred()) SWIG_fail;
28375 }
28376 {
28377 resultobj = SWIG_From_long(static_cast<long >(result));
28378 }
28379 return resultobj;
28380 fail:
28381 return NULL;
28382 }
28383
28384
28385 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28386 PyObject *resultobj = NULL;
28387 wxWindow *arg1 = (wxWindow *) 0 ;
28388 int arg2 ;
28389 bool result;
28390 PyObject * obj0 = 0 ;
28391 PyObject * obj1 = 0 ;
28392 char *kwnames[] = {
28393 (char *) "self",(char *) "flag", NULL
28394 };
28395
28396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
28397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28398 if (SWIG_arg_fail(1)) SWIG_fail;
28399 {
28400 arg2 = static_cast<int >(SWIG_As_int(obj1));
28401 if (SWIG_arg_fail(2)) SWIG_fail;
28402 }
28403 {
28404 PyThreadState* __tstate = wxPyBeginAllowThreads();
28405 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
28406
28407 wxPyEndAllowThreads(__tstate);
28408 if (PyErr_Occurred()) SWIG_fail;
28409 }
28410 {
28411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28412 }
28413 return resultobj;
28414 fail:
28415 return NULL;
28416 }
28417
28418
28419 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
28420 PyObject *resultobj = NULL;
28421 wxWindow *arg1 = (wxWindow *) 0 ;
28422 bool result;
28423 PyObject * obj0 = 0 ;
28424 char *kwnames[] = {
28425 (char *) "self", NULL
28426 };
28427
28428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
28429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28430 if (SWIG_arg_fail(1)) SWIG_fail;
28431 {
28432 PyThreadState* __tstate = wxPyBeginAllowThreads();
28433 result = (bool)((wxWindow const *)arg1)->IsRetained();
28434
28435 wxPyEndAllowThreads(__tstate);
28436 if (PyErr_Occurred()) SWIG_fail;
28437 }
28438 {
28439 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28440 }
28441 return resultobj;
28442 fail:
28443 return NULL;
28444 }
28445
28446
28447 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28448 PyObject *resultobj = NULL;
28449 wxWindow *arg1 = (wxWindow *) 0 ;
28450 long arg2 ;
28451 PyObject * obj0 = 0 ;
28452 PyObject * obj1 = 0 ;
28453 char *kwnames[] = {
28454 (char *) "self",(char *) "exStyle", NULL
28455 };
28456
28457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
28458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28459 if (SWIG_arg_fail(1)) SWIG_fail;
28460 {
28461 arg2 = static_cast<long >(SWIG_As_long(obj1));
28462 if (SWIG_arg_fail(2)) SWIG_fail;
28463 }
28464 {
28465 PyThreadState* __tstate = wxPyBeginAllowThreads();
28466 (arg1)->SetExtraStyle(arg2);
28467
28468 wxPyEndAllowThreads(__tstate);
28469 if (PyErr_Occurred()) SWIG_fail;
28470 }
28471 Py_INCREF(Py_None); resultobj = Py_None;
28472 return resultobj;
28473 fail:
28474 return NULL;
28475 }
28476
28477
28478 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28479 PyObject *resultobj = NULL;
28480 wxWindow *arg1 = (wxWindow *) 0 ;
28481 long result;
28482 PyObject * obj0 = 0 ;
28483 char *kwnames[] = {
28484 (char *) "self", NULL
28485 };
28486
28487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
28488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28489 if (SWIG_arg_fail(1)) SWIG_fail;
28490 {
28491 PyThreadState* __tstate = wxPyBeginAllowThreads();
28492 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
28493
28494 wxPyEndAllowThreads(__tstate);
28495 if (PyErr_Occurred()) SWIG_fail;
28496 }
28497 {
28498 resultobj = SWIG_From_long(static_cast<long >(result));
28499 }
28500 return resultobj;
28501 fail:
28502 return NULL;
28503 }
28504
28505
28506 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
28507 PyObject *resultobj = NULL;
28508 wxWindow *arg1 = (wxWindow *) 0 ;
28509 bool arg2 = (bool) true ;
28510 PyObject * obj0 = 0 ;
28511 PyObject * obj1 = 0 ;
28512 char *kwnames[] = {
28513 (char *) "self",(char *) "modal", NULL
28514 };
28515
28516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
28517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28518 if (SWIG_arg_fail(1)) SWIG_fail;
28519 if (obj1) {
28520 {
28521 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28522 if (SWIG_arg_fail(2)) SWIG_fail;
28523 }
28524 }
28525 {
28526 PyThreadState* __tstate = wxPyBeginAllowThreads();
28527 (arg1)->MakeModal(arg2);
28528
28529 wxPyEndAllowThreads(__tstate);
28530 if (PyErr_Occurred()) SWIG_fail;
28531 }
28532 Py_INCREF(Py_None); resultobj = Py_None;
28533 return resultobj;
28534 fail:
28535 return NULL;
28536 }
28537
28538
28539 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28540 PyObject *resultobj = NULL;
28541 wxWindow *arg1 = (wxWindow *) 0 ;
28542 bool arg2 ;
28543 PyObject * obj0 = 0 ;
28544 PyObject * obj1 = 0 ;
28545 char *kwnames[] = {
28546 (char *) "self",(char *) "enableTheme", NULL
28547 };
28548
28549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
28550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28551 if (SWIG_arg_fail(1)) SWIG_fail;
28552 {
28553 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28554 if (SWIG_arg_fail(2)) SWIG_fail;
28555 }
28556 {
28557 PyThreadState* __tstate = wxPyBeginAllowThreads();
28558 (arg1)->SetThemeEnabled(arg2);
28559
28560 wxPyEndAllowThreads(__tstate);
28561 if (PyErr_Occurred()) SWIG_fail;
28562 }
28563 Py_INCREF(Py_None); resultobj = Py_None;
28564 return resultobj;
28565 fail:
28566 return NULL;
28567 }
28568
28569
28570 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28571 PyObject *resultobj = NULL;
28572 wxWindow *arg1 = (wxWindow *) 0 ;
28573 bool result;
28574 PyObject * obj0 = 0 ;
28575 char *kwnames[] = {
28576 (char *) "self", NULL
28577 };
28578
28579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
28580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28581 if (SWIG_arg_fail(1)) SWIG_fail;
28582 {
28583 PyThreadState* __tstate = wxPyBeginAllowThreads();
28584 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
28585
28586 wxPyEndAllowThreads(__tstate);
28587 if (PyErr_Occurred()) SWIG_fail;
28588 }
28589 {
28590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28591 }
28592 return resultobj;
28593 fail:
28594 return NULL;
28595 }
28596
28597
28598 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28599 PyObject *resultobj = NULL;
28600 wxWindow *arg1 = (wxWindow *) 0 ;
28601 PyObject * obj0 = 0 ;
28602 char *kwnames[] = {
28603 (char *) "self", NULL
28604 };
28605
28606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
28607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28608 if (SWIG_arg_fail(1)) SWIG_fail;
28609 {
28610 PyThreadState* __tstate = wxPyBeginAllowThreads();
28611 (arg1)->SetFocus();
28612
28613 wxPyEndAllowThreads(__tstate);
28614 if (PyErr_Occurred()) SWIG_fail;
28615 }
28616 Py_INCREF(Py_None); resultobj = Py_None;
28617 return resultobj;
28618 fail:
28619 return NULL;
28620 }
28621
28622
28623 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
28624 PyObject *resultobj = NULL;
28625 wxWindow *arg1 = (wxWindow *) 0 ;
28626 PyObject * obj0 = 0 ;
28627 char *kwnames[] = {
28628 (char *) "self", NULL
28629 };
28630
28631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
28632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28633 if (SWIG_arg_fail(1)) SWIG_fail;
28634 {
28635 PyThreadState* __tstate = wxPyBeginAllowThreads();
28636 (arg1)->SetFocusFromKbd();
28637
28638 wxPyEndAllowThreads(__tstate);
28639 if (PyErr_Occurred()) SWIG_fail;
28640 }
28641 Py_INCREF(Py_None); resultobj = Py_None;
28642 return resultobj;
28643 fail:
28644 return NULL;
28645 }
28646
28647
28648 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28649 PyObject *resultobj = NULL;
28650 wxWindow *result;
28651 char *kwnames[] = {
28652 NULL
28653 };
28654
28655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
28656 {
28657 if (!wxPyCheckForApp()) SWIG_fail;
28658 PyThreadState* __tstate = wxPyBeginAllowThreads();
28659 result = (wxWindow *)wxWindow::FindFocus();
28660
28661 wxPyEndAllowThreads(__tstate);
28662 if (PyErr_Occurred()) SWIG_fail;
28663 }
28664 {
28665 resultobj = wxPyMake_wxObject(result, 0);
28666 }
28667 return resultobj;
28668 fail:
28669 return NULL;
28670 }
28671
28672
28673 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28674 PyObject *resultobj = NULL;
28675 wxWindow *arg1 = (wxWindow *) 0 ;
28676 bool result;
28677 PyObject * obj0 = 0 ;
28678 char *kwnames[] = {
28679 (char *) "self", NULL
28680 };
28681
28682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
28683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28684 if (SWIG_arg_fail(1)) SWIG_fail;
28685 {
28686 PyThreadState* __tstate = wxPyBeginAllowThreads();
28687 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
28688
28689 wxPyEndAllowThreads(__tstate);
28690 if (PyErr_Occurred()) SWIG_fail;
28691 }
28692 {
28693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28694 }
28695 return resultobj;
28696 fail:
28697 return NULL;
28698 }
28699
28700
28701 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
28702 PyObject *resultobj = NULL;
28703 wxWindow *arg1 = (wxWindow *) 0 ;
28704 bool result;
28705 PyObject * obj0 = 0 ;
28706 char *kwnames[] = {
28707 (char *) "self", NULL
28708 };
28709
28710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
28711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28712 if (SWIG_arg_fail(1)) SWIG_fail;
28713 {
28714 PyThreadState* __tstate = wxPyBeginAllowThreads();
28715 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
28716
28717 wxPyEndAllowThreads(__tstate);
28718 if (PyErr_Occurred()) SWIG_fail;
28719 }
28720 {
28721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28722 }
28723 return resultobj;
28724 fail:
28725 return NULL;
28726 }
28727
28728
28729 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28730 PyObject *resultobj = NULL;
28731 wxWindow *arg1 = (wxWindow *) 0 ;
28732 wxWindow *result;
28733 PyObject * obj0 = 0 ;
28734 char *kwnames[] = {
28735 (char *) "self", NULL
28736 };
28737
28738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
28739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28740 if (SWIG_arg_fail(1)) SWIG_fail;
28741 {
28742 PyThreadState* __tstate = wxPyBeginAllowThreads();
28743 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
28744
28745 wxPyEndAllowThreads(__tstate);
28746 if (PyErr_Occurred()) SWIG_fail;
28747 }
28748 {
28749 resultobj = wxPyMake_wxObject(result, 0);
28750 }
28751 return resultobj;
28752 fail:
28753 return NULL;
28754 }
28755
28756
28757 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28758 PyObject *resultobj = NULL;
28759 wxWindow *arg1 = (wxWindow *) 0 ;
28760 wxWindow *arg2 = (wxWindow *) 0 ;
28761 wxWindow *result;
28762 PyObject * obj0 = 0 ;
28763 PyObject * obj1 = 0 ;
28764 char *kwnames[] = {
28765 (char *) "self",(char *) "child", NULL
28766 };
28767
28768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28770 if (SWIG_arg_fail(1)) SWIG_fail;
28771 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28772 if (SWIG_arg_fail(2)) SWIG_fail;
28773 {
28774 PyThreadState* __tstate = wxPyBeginAllowThreads();
28775 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
28776
28777 wxPyEndAllowThreads(__tstate);
28778 if (PyErr_Occurred()) SWIG_fail;
28779 }
28780 {
28781 resultobj = wxPyMake_wxObject(result, 0);
28782 }
28783 return resultobj;
28784 fail:
28785 return NULL;
28786 }
28787
28788
28789 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28790 PyObject *resultobj = NULL;
28791 wxWindow *arg1 = (wxWindow *) 0 ;
28792 wxWindow *arg2 = (wxWindow *) 0 ;
28793 PyObject * obj0 = 0 ;
28794 PyObject * obj1 = 0 ;
28795 char *kwnames[] = {
28796 (char *) "self",(char *) "win", NULL
28797 };
28798
28799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28801 if (SWIG_arg_fail(1)) SWIG_fail;
28802 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28803 if (SWIG_arg_fail(2)) SWIG_fail;
28804 {
28805 PyThreadState* __tstate = wxPyBeginAllowThreads();
28806 (arg1)->SetTmpDefaultItem(arg2);
28807
28808 wxPyEndAllowThreads(__tstate);
28809 if (PyErr_Occurred()) SWIG_fail;
28810 }
28811 Py_INCREF(Py_None); resultobj = Py_None;
28812 return resultobj;
28813 fail:
28814 return NULL;
28815 }
28816
28817
28818 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28819 PyObject *resultobj = NULL;
28820 wxWindow *arg1 = (wxWindow *) 0 ;
28821 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28822 bool result;
28823 PyObject * obj0 = 0 ;
28824 PyObject * obj1 = 0 ;
28825 char *kwnames[] = {
28826 (char *) "self",(char *) "flags", NULL
28827 };
28828
28829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28831 if (SWIG_arg_fail(1)) SWIG_fail;
28832 if (obj1) {
28833 {
28834 arg2 = static_cast<int >(SWIG_As_int(obj1));
28835 if (SWIG_arg_fail(2)) SWIG_fail;
28836 }
28837 }
28838 {
28839 PyThreadState* __tstate = wxPyBeginAllowThreads();
28840 result = (bool)(arg1)->Navigate(arg2);
28841
28842 wxPyEndAllowThreads(__tstate);
28843 if (PyErr_Occurred()) SWIG_fail;
28844 }
28845 {
28846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28847 }
28848 return resultobj;
28849 fail:
28850 return NULL;
28851 }
28852
28853
28854 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28855 PyObject *resultobj = NULL;
28856 wxWindow *arg1 = (wxWindow *) 0 ;
28857 wxWindow *arg2 = (wxWindow *) 0 ;
28858 PyObject * obj0 = 0 ;
28859 PyObject * obj1 = 0 ;
28860 char *kwnames[] = {
28861 (char *) "self",(char *) "win", NULL
28862 };
28863
28864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28866 if (SWIG_arg_fail(1)) SWIG_fail;
28867 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28868 if (SWIG_arg_fail(2)) SWIG_fail;
28869 {
28870 PyThreadState* __tstate = wxPyBeginAllowThreads();
28871 (arg1)->MoveAfterInTabOrder(arg2);
28872
28873 wxPyEndAllowThreads(__tstate);
28874 if (PyErr_Occurred()) SWIG_fail;
28875 }
28876 Py_INCREF(Py_None); resultobj = Py_None;
28877 return resultobj;
28878 fail:
28879 return NULL;
28880 }
28881
28882
28883 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28884 PyObject *resultobj = NULL;
28885 wxWindow *arg1 = (wxWindow *) 0 ;
28886 wxWindow *arg2 = (wxWindow *) 0 ;
28887 PyObject * obj0 = 0 ;
28888 PyObject * obj1 = 0 ;
28889 char *kwnames[] = {
28890 (char *) "self",(char *) "win", NULL
28891 };
28892
28893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28895 if (SWIG_arg_fail(1)) SWIG_fail;
28896 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28897 if (SWIG_arg_fail(2)) SWIG_fail;
28898 {
28899 PyThreadState* __tstate = wxPyBeginAllowThreads();
28900 (arg1)->MoveBeforeInTabOrder(arg2);
28901
28902 wxPyEndAllowThreads(__tstate);
28903 if (PyErr_Occurred()) SWIG_fail;
28904 }
28905 Py_INCREF(Py_None); resultobj = Py_None;
28906 return resultobj;
28907 fail:
28908 return NULL;
28909 }
28910
28911
28912 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28913 PyObject *resultobj = NULL;
28914 wxWindow *arg1 = (wxWindow *) 0 ;
28915 PyObject *result;
28916 PyObject * obj0 = 0 ;
28917 char *kwnames[] = {
28918 (char *) "self", NULL
28919 };
28920
28921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28923 if (SWIG_arg_fail(1)) SWIG_fail;
28924 {
28925 PyThreadState* __tstate = wxPyBeginAllowThreads();
28926 result = (PyObject *)wxWindow_GetChildren(arg1);
28927
28928 wxPyEndAllowThreads(__tstate);
28929 if (PyErr_Occurred()) SWIG_fail;
28930 }
28931 resultobj = result;
28932 return resultobj;
28933 fail:
28934 return NULL;
28935 }
28936
28937
28938 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28939 PyObject *resultobj = NULL;
28940 wxWindow *arg1 = (wxWindow *) 0 ;
28941 wxWindow *result;
28942 PyObject * obj0 = 0 ;
28943 char *kwnames[] = {
28944 (char *) "self", NULL
28945 };
28946
28947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28949 if (SWIG_arg_fail(1)) SWIG_fail;
28950 {
28951 PyThreadState* __tstate = wxPyBeginAllowThreads();
28952 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28953
28954 wxPyEndAllowThreads(__tstate);
28955 if (PyErr_Occurred()) SWIG_fail;
28956 }
28957 {
28958 resultobj = wxPyMake_wxObject(result, 0);
28959 }
28960 return resultobj;
28961 fail:
28962 return NULL;
28963 }
28964
28965
28966 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28967 PyObject *resultobj = NULL;
28968 wxWindow *arg1 = (wxWindow *) 0 ;
28969 wxWindow *result;
28970 PyObject * obj0 = 0 ;
28971 char *kwnames[] = {
28972 (char *) "self", NULL
28973 };
28974
28975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28977 if (SWIG_arg_fail(1)) SWIG_fail;
28978 {
28979 PyThreadState* __tstate = wxPyBeginAllowThreads();
28980 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28981
28982 wxPyEndAllowThreads(__tstate);
28983 if (PyErr_Occurred()) SWIG_fail;
28984 }
28985 {
28986 resultobj = wxPyMake_wxObject(result, 0);
28987 }
28988 return resultobj;
28989 fail:
28990 return NULL;
28991 }
28992
28993
28994 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28995 PyObject *resultobj = NULL;
28996 wxWindow *arg1 = (wxWindow *) 0 ;
28997 bool result;
28998 PyObject * obj0 = 0 ;
28999 char *kwnames[] = {
29000 (char *) "self", NULL
29001 };
29002
29003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
29004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29005 if (SWIG_arg_fail(1)) SWIG_fail;
29006 {
29007 PyThreadState* __tstate = wxPyBeginAllowThreads();
29008 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
29009
29010 wxPyEndAllowThreads(__tstate);
29011 if (PyErr_Occurred()) SWIG_fail;
29012 }
29013 {
29014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29015 }
29016 return resultobj;
29017 fail:
29018 return NULL;
29019 }
29020
29021
29022 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
29023 PyObject *resultobj = NULL;
29024 wxWindow *arg1 = (wxWindow *) 0 ;
29025 wxWindow *arg2 = (wxWindow *) 0 ;
29026 bool result;
29027 PyObject * obj0 = 0 ;
29028 PyObject * obj1 = 0 ;
29029 char *kwnames[] = {
29030 (char *) "self",(char *) "newParent", NULL
29031 };
29032
29033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
29034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29035 if (SWIG_arg_fail(1)) SWIG_fail;
29036 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29037 if (SWIG_arg_fail(2)) SWIG_fail;
29038 {
29039 PyThreadState* __tstate = wxPyBeginAllowThreads();
29040 result = (bool)(arg1)->Reparent(arg2);
29041
29042 wxPyEndAllowThreads(__tstate);
29043 if (PyErr_Occurred()) SWIG_fail;
29044 }
29045 {
29046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29047 }
29048 return resultobj;
29049 fail:
29050 return NULL;
29051 }
29052
29053
29054 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
29055 PyObject *resultobj = NULL;
29056 wxWindow *arg1 = (wxWindow *) 0 ;
29057 wxWindow *arg2 = (wxWindow *) 0 ;
29058 PyObject * obj0 = 0 ;
29059 PyObject * obj1 = 0 ;
29060 char *kwnames[] = {
29061 (char *) "self",(char *) "child", NULL
29062 };
29063
29064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
29065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29066 if (SWIG_arg_fail(1)) SWIG_fail;
29067 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29068 if (SWIG_arg_fail(2)) SWIG_fail;
29069 {
29070 PyThreadState* __tstate = wxPyBeginAllowThreads();
29071 (arg1)->AddChild(arg2);
29072
29073 wxPyEndAllowThreads(__tstate);
29074 if (PyErr_Occurred()) SWIG_fail;
29075 }
29076 Py_INCREF(Py_None); resultobj = Py_None;
29077 return resultobj;
29078 fail:
29079 return NULL;
29080 }
29081
29082
29083 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
29084 PyObject *resultobj = NULL;
29085 wxWindow *arg1 = (wxWindow *) 0 ;
29086 wxWindow *arg2 = (wxWindow *) 0 ;
29087 PyObject * obj0 = 0 ;
29088 PyObject * obj1 = 0 ;
29089 char *kwnames[] = {
29090 (char *) "self",(char *) "child", NULL
29091 };
29092
29093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
29094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29095 if (SWIG_arg_fail(1)) SWIG_fail;
29096 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29097 if (SWIG_arg_fail(2)) SWIG_fail;
29098 {
29099 PyThreadState* __tstate = wxPyBeginAllowThreads();
29100 (arg1)->RemoveChild(arg2);
29101
29102 wxPyEndAllowThreads(__tstate);
29103 if (PyErr_Occurred()) SWIG_fail;
29104 }
29105 Py_INCREF(Py_None); resultobj = Py_None;
29106 return resultobj;
29107 fail:
29108 return NULL;
29109 }
29110
29111
29112 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
29113 PyObject *resultobj = NULL;
29114 wxWindow *arg1 = (wxWindow *) 0 ;
29115 long arg2 ;
29116 wxWindow *result;
29117 PyObject * obj0 = 0 ;
29118 PyObject * obj1 = 0 ;
29119 char *kwnames[] = {
29120 (char *) "self",(char *) "winid", NULL
29121 };
29122
29123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
29124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29125 if (SWIG_arg_fail(1)) SWIG_fail;
29126 {
29127 arg2 = static_cast<long >(SWIG_As_long(obj1));
29128 if (SWIG_arg_fail(2)) SWIG_fail;
29129 }
29130 {
29131 PyThreadState* __tstate = wxPyBeginAllowThreads();
29132 result = (wxWindow *)(arg1)->FindWindow(arg2);
29133
29134 wxPyEndAllowThreads(__tstate);
29135 if (PyErr_Occurred()) SWIG_fail;
29136 }
29137 {
29138 resultobj = wxPyMake_wxObject(result, 0);
29139 }
29140 return resultobj;
29141 fail:
29142 return NULL;
29143 }
29144
29145
29146 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
29147 PyObject *resultobj = NULL;
29148 wxWindow *arg1 = (wxWindow *) 0 ;
29149 wxString *arg2 = 0 ;
29150 wxWindow *result;
29151 bool temp2 = false ;
29152 PyObject * obj0 = 0 ;
29153 PyObject * obj1 = 0 ;
29154 char *kwnames[] = {
29155 (char *) "self",(char *) "name", NULL
29156 };
29157
29158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
29159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29160 if (SWIG_arg_fail(1)) SWIG_fail;
29161 {
29162 arg2 = wxString_in_helper(obj1);
29163 if (arg2 == NULL) SWIG_fail;
29164 temp2 = true;
29165 }
29166 {
29167 PyThreadState* __tstate = wxPyBeginAllowThreads();
29168 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
29169
29170 wxPyEndAllowThreads(__tstate);
29171 if (PyErr_Occurred()) SWIG_fail;
29172 }
29173 {
29174 resultobj = wxPyMake_wxObject(result, 0);
29175 }
29176 {
29177 if (temp2)
29178 delete arg2;
29179 }
29180 return resultobj;
29181 fail:
29182 {
29183 if (temp2)
29184 delete arg2;
29185 }
29186 return NULL;
29187 }
29188
29189
29190 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29191 PyObject *resultobj = NULL;
29192 wxWindow *arg1 = (wxWindow *) 0 ;
29193 wxEvtHandler *result;
29194 PyObject * obj0 = 0 ;
29195 char *kwnames[] = {
29196 (char *) "self", NULL
29197 };
29198
29199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
29200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29201 if (SWIG_arg_fail(1)) SWIG_fail;
29202 {
29203 PyThreadState* __tstate = wxPyBeginAllowThreads();
29204 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
29205
29206 wxPyEndAllowThreads(__tstate);
29207 if (PyErr_Occurred()) SWIG_fail;
29208 }
29209 {
29210 resultobj = wxPyMake_wxObject(result, 0);
29211 }
29212 return resultobj;
29213 fail:
29214 return NULL;
29215 }
29216
29217
29218 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29219 PyObject *resultobj = NULL;
29220 wxWindow *arg1 = (wxWindow *) 0 ;
29221 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29222 PyObject * obj0 = 0 ;
29223 PyObject * obj1 = 0 ;
29224 char *kwnames[] = {
29225 (char *) "self",(char *) "handler", NULL
29226 };
29227
29228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
29229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29230 if (SWIG_arg_fail(1)) SWIG_fail;
29231 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29232 if (SWIG_arg_fail(2)) SWIG_fail;
29233 {
29234 PyThreadState* __tstate = wxPyBeginAllowThreads();
29235 (arg1)->SetEventHandler(arg2);
29236
29237 wxPyEndAllowThreads(__tstate);
29238 if (PyErr_Occurred()) SWIG_fail;
29239 }
29240 Py_INCREF(Py_None); resultobj = Py_None;
29241 return resultobj;
29242 fail:
29243 return NULL;
29244 }
29245
29246
29247 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29248 PyObject *resultobj = NULL;
29249 wxWindow *arg1 = (wxWindow *) 0 ;
29250 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29251 PyObject * obj0 = 0 ;
29252 PyObject * obj1 = 0 ;
29253 char *kwnames[] = {
29254 (char *) "self",(char *) "handler", NULL
29255 };
29256
29257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
29258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29259 if (SWIG_arg_fail(1)) SWIG_fail;
29260 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29261 if (SWIG_arg_fail(2)) SWIG_fail;
29262 {
29263 PyThreadState* __tstate = wxPyBeginAllowThreads();
29264 (arg1)->PushEventHandler(arg2);
29265
29266 wxPyEndAllowThreads(__tstate);
29267 if (PyErr_Occurred()) SWIG_fail;
29268 }
29269 Py_INCREF(Py_None); resultobj = Py_None;
29270 return resultobj;
29271 fail:
29272 return NULL;
29273 }
29274
29275
29276 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29277 PyObject *resultobj = NULL;
29278 wxWindow *arg1 = (wxWindow *) 0 ;
29279 bool arg2 = (bool) false ;
29280 wxEvtHandler *result;
29281 PyObject * obj0 = 0 ;
29282 PyObject * obj1 = 0 ;
29283 char *kwnames[] = {
29284 (char *) "self",(char *) "deleteHandler", NULL
29285 };
29286
29287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
29288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29289 if (SWIG_arg_fail(1)) SWIG_fail;
29290 if (obj1) {
29291 {
29292 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
29293 if (SWIG_arg_fail(2)) SWIG_fail;
29294 }
29295 }
29296 {
29297 PyThreadState* __tstate = wxPyBeginAllowThreads();
29298 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
29299
29300 wxPyEndAllowThreads(__tstate);
29301 if (PyErr_Occurred()) SWIG_fail;
29302 }
29303 {
29304 resultobj = wxPyMake_wxObject(result, 0);
29305 }
29306 return resultobj;
29307 fail:
29308 return NULL;
29309 }
29310
29311
29312 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29313 PyObject *resultobj = NULL;
29314 wxWindow *arg1 = (wxWindow *) 0 ;
29315 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29316 bool result;
29317 PyObject * obj0 = 0 ;
29318 PyObject * obj1 = 0 ;
29319 char *kwnames[] = {
29320 (char *) "self",(char *) "handler", NULL
29321 };
29322
29323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
29324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29325 if (SWIG_arg_fail(1)) SWIG_fail;
29326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29327 if (SWIG_arg_fail(2)) SWIG_fail;
29328 {
29329 PyThreadState* __tstate = wxPyBeginAllowThreads();
29330 result = (bool)(arg1)->RemoveEventHandler(arg2);
29331
29332 wxPyEndAllowThreads(__tstate);
29333 if (PyErr_Occurred()) SWIG_fail;
29334 }
29335 {
29336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29337 }
29338 return resultobj;
29339 fail:
29340 return NULL;
29341 }
29342
29343
29344 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29345 PyObject *resultobj = NULL;
29346 wxWindow *arg1 = (wxWindow *) 0 ;
29347 wxValidator *arg2 = 0 ;
29348 PyObject * obj0 = 0 ;
29349 PyObject * obj1 = 0 ;
29350 char *kwnames[] = {
29351 (char *) "self",(char *) "validator", NULL
29352 };
29353
29354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
29355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29356 if (SWIG_arg_fail(1)) SWIG_fail;
29357 {
29358 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
29359 if (SWIG_arg_fail(2)) SWIG_fail;
29360 if (arg2 == NULL) {
29361 SWIG_null_ref("wxValidator");
29362 }
29363 if (SWIG_arg_fail(2)) SWIG_fail;
29364 }
29365 {
29366 PyThreadState* __tstate = wxPyBeginAllowThreads();
29367 (arg1)->SetValidator((wxValidator const &)*arg2);
29368
29369 wxPyEndAllowThreads(__tstate);
29370 if (PyErr_Occurred()) SWIG_fail;
29371 }
29372 Py_INCREF(Py_None); resultobj = Py_None;
29373 return resultobj;
29374 fail:
29375 return NULL;
29376 }
29377
29378
29379 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29380 PyObject *resultobj = NULL;
29381 wxWindow *arg1 = (wxWindow *) 0 ;
29382 wxValidator *result;
29383 PyObject * obj0 = 0 ;
29384 char *kwnames[] = {
29385 (char *) "self", NULL
29386 };
29387
29388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
29389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29390 if (SWIG_arg_fail(1)) SWIG_fail;
29391 {
29392 PyThreadState* __tstate = wxPyBeginAllowThreads();
29393 result = (wxValidator *)(arg1)->GetValidator();
29394
29395 wxPyEndAllowThreads(__tstate);
29396 if (PyErr_Occurred()) SWIG_fail;
29397 }
29398 {
29399 resultobj = wxPyMake_wxObject(result, 0);
29400 }
29401 return resultobj;
29402 fail:
29403 return NULL;
29404 }
29405
29406
29407 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
29408 PyObject *resultobj = NULL;
29409 wxWindow *arg1 = (wxWindow *) 0 ;
29410 bool result;
29411 PyObject * obj0 = 0 ;
29412 char *kwnames[] = {
29413 (char *) "self", NULL
29414 };
29415
29416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
29417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29418 if (SWIG_arg_fail(1)) SWIG_fail;
29419 {
29420 PyThreadState* __tstate = wxPyBeginAllowThreads();
29421 result = (bool)(arg1)->Validate();
29422
29423 wxPyEndAllowThreads(__tstate);
29424 if (PyErr_Occurred()) SWIG_fail;
29425 }
29426 {
29427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29428 }
29429 return resultobj;
29430 fail:
29431 return NULL;
29432 }
29433
29434
29435 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29436 PyObject *resultobj = NULL;
29437 wxWindow *arg1 = (wxWindow *) 0 ;
29438 bool result;
29439 PyObject * obj0 = 0 ;
29440 char *kwnames[] = {
29441 (char *) "self", NULL
29442 };
29443
29444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
29445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29446 if (SWIG_arg_fail(1)) SWIG_fail;
29447 {
29448 PyThreadState* __tstate = wxPyBeginAllowThreads();
29449 result = (bool)(arg1)->TransferDataToWindow();
29450
29451 wxPyEndAllowThreads(__tstate);
29452 if (PyErr_Occurred()) SWIG_fail;
29453 }
29454 {
29455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29456 }
29457 return resultobj;
29458 fail:
29459 return NULL;
29460 }
29461
29462
29463 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29464 PyObject *resultobj = NULL;
29465 wxWindow *arg1 = (wxWindow *) 0 ;
29466 bool result;
29467 PyObject * obj0 = 0 ;
29468 char *kwnames[] = {
29469 (char *) "self", NULL
29470 };
29471
29472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
29473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29474 if (SWIG_arg_fail(1)) SWIG_fail;
29475 {
29476 PyThreadState* __tstate = wxPyBeginAllowThreads();
29477 result = (bool)(arg1)->TransferDataFromWindow();
29478
29479 wxPyEndAllowThreads(__tstate);
29480 if (PyErr_Occurred()) SWIG_fail;
29481 }
29482 {
29483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29484 }
29485 return resultobj;
29486 fail:
29487 return NULL;
29488 }
29489
29490
29491 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29492 PyObject *resultobj = NULL;
29493 wxWindow *arg1 = (wxWindow *) 0 ;
29494 PyObject * obj0 = 0 ;
29495 char *kwnames[] = {
29496 (char *) "self", NULL
29497 };
29498
29499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
29500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29501 if (SWIG_arg_fail(1)) SWIG_fail;
29502 {
29503 PyThreadState* __tstate = wxPyBeginAllowThreads();
29504 (arg1)->InitDialog();
29505
29506 wxPyEndAllowThreads(__tstate);
29507 if (PyErr_Occurred()) SWIG_fail;
29508 }
29509 Py_INCREF(Py_None); resultobj = Py_None;
29510 return resultobj;
29511 fail:
29512 return NULL;
29513 }
29514
29515
29516 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29517 PyObject *resultobj = NULL;
29518 wxWindow *arg1 = (wxWindow *) 0 ;
29519 wxAcceleratorTable *arg2 = 0 ;
29520 PyObject * obj0 = 0 ;
29521 PyObject * obj1 = 0 ;
29522 char *kwnames[] = {
29523 (char *) "self",(char *) "accel", NULL
29524 };
29525
29526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
29527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29528 if (SWIG_arg_fail(1)) SWIG_fail;
29529 {
29530 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
29531 if (SWIG_arg_fail(2)) SWIG_fail;
29532 if (arg2 == NULL) {
29533 SWIG_null_ref("wxAcceleratorTable");
29534 }
29535 if (SWIG_arg_fail(2)) SWIG_fail;
29536 }
29537 {
29538 PyThreadState* __tstate = wxPyBeginAllowThreads();
29539 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
29540
29541 wxPyEndAllowThreads(__tstate);
29542 if (PyErr_Occurred()) SWIG_fail;
29543 }
29544 Py_INCREF(Py_None); resultobj = Py_None;
29545 return resultobj;
29546 fail:
29547 return NULL;
29548 }
29549
29550
29551 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29552 PyObject *resultobj = NULL;
29553 wxWindow *arg1 = (wxWindow *) 0 ;
29554 wxAcceleratorTable *result;
29555 PyObject * obj0 = 0 ;
29556 char *kwnames[] = {
29557 (char *) "self", NULL
29558 };
29559
29560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
29561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29562 if (SWIG_arg_fail(1)) SWIG_fail;
29563 {
29564 PyThreadState* __tstate = wxPyBeginAllowThreads();
29565 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
29566
29567 wxPyEndAllowThreads(__tstate);
29568 if (PyErr_Occurred()) SWIG_fail;
29569 }
29570 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
29571 return resultobj;
29572 fail:
29573 return NULL;
29574 }
29575
29576
29577 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29578 PyObject *resultobj = NULL;
29579 wxWindow *arg1 = (wxWindow *) 0 ;
29580 int arg2 ;
29581 int arg3 ;
29582 int arg4 ;
29583 bool result;
29584 PyObject * obj0 = 0 ;
29585 PyObject * obj1 = 0 ;
29586 PyObject * obj2 = 0 ;
29587 PyObject * obj3 = 0 ;
29588 char *kwnames[] = {
29589 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
29590 };
29591
29592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29594 if (SWIG_arg_fail(1)) SWIG_fail;
29595 {
29596 arg2 = static_cast<int >(SWIG_As_int(obj1));
29597 if (SWIG_arg_fail(2)) SWIG_fail;
29598 }
29599 {
29600 arg3 = static_cast<int >(SWIG_As_int(obj2));
29601 if (SWIG_arg_fail(3)) SWIG_fail;
29602 }
29603 {
29604 arg4 = static_cast<int >(SWIG_As_int(obj3));
29605 if (SWIG_arg_fail(4)) SWIG_fail;
29606 }
29607 {
29608 PyThreadState* __tstate = wxPyBeginAllowThreads();
29609 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
29610
29611 wxPyEndAllowThreads(__tstate);
29612 if (PyErr_Occurred()) SWIG_fail;
29613 }
29614 {
29615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29616 }
29617 return resultobj;
29618 fail:
29619 return NULL;
29620 }
29621
29622
29623 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29624 PyObject *resultobj = NULL;
29625 wxWindow *arg1 = (wxWindow *) 0 ;
29626 int arg2 ;
29627 bool result;
29628 PyObject * obj0 = 0 ;
29629 PyObject * obj1 = 0 ;
29630 char *kwnames[] = {
29631 (char *) "self",(char *) "hotkeyId", NULL
29632 };
29633
29634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
29635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29636 if (SWIG_arg_fail(1)) SWIG_fail;
29637 {
29638 arg2 = static_cast<int >(SWIG_As_int(obj1));
29639 if (SWIG_arg_fail(2)) SWIG_fail;
29640 }
29641 {
29642 PyThreadState* __tstate = wxPyBeginAllowThreads();
29643 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
29644
29645 wxPyEndAllowThreads(__tstate);
29646 if (PyErr_Occurred()) SWIG_fail;
29647 }
29648 {
29649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29650 }
29651 return resultobj;
29652 fail:
29653 return NULL;
29654 }
29655
29656
29657 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29658 PyObject *resultobj = NULL;
29659 wxWindow *arg1 = (wxWindow *) 0 ;
29660 wxPoint *arg2 = 0 ;
29661 wxPoint result;
29662 wxPoint temp2 ;
29663 PyObject * obj0 = 0 ;
29664 PyObject * obj1 = 0 ;
29665 char *kwnames[] = {
29666 (char *) "self",(char *) "pt", NULL
29667 };
29668
29669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
29670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29671 if (SWIG_arg_fail(1)) SWIG_fail;
29672 {
29673 arg2 = &temp2;
29674 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29675 }
29676 {
29677 PyThreadState* __tstate = wxPyBeginAllowThreads();
29678 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29679
29680 wxPyEndAllowThreads(__tstate);
29681 if (PyErr_Occurred()) SWIG_fail;
29682 }
29683 {
29684 wxPoint * resultptr;
29685 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29686 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29687 }
29688 return resultobj;
29689 fail:
29690 return NULL;
29691 }
29692
29693
29694 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29695 PyObject *resultobj = NULL;
29696 wxWindow *arg1 = (wxWindow *) 0 ;
29697 wxSize *arg2 = 0 ;
29698 wxSize result;
29699 wxSize temp2 ;
29700 PyObject * obj0 = 0 ;
29701 PyObject * obj1 = 0 ;
29702 char *kwnames[] = {
29703 (char *) "self",(char *) "sz", NULL
29704 };
29705
29706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
29707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29708 if (SWIG_arg_fail(1)) SWIG_fail;
29709 {
29710 arg2 = &temp2;
29711 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29712 }
29713 {
29714 PyThreadState* __tstate = wxPyBeginAllowThreads();
29715 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29716
29717 wxPyEndAllowThreads(__tstate);
29718 if (PyErr_Occurred()) SWIG_fail;
29719 }
29720 {
29721 wxSize * resultptr;
29722 resultptr = new wxSize(static_cast<wxSize & >(result));
29723 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29724 }
29725 return resultobj;
29726 fail:
29727 return NULL;
29728 }
29729
29730
29731 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
29732 PyObject *resultobj = NULL;
29733 wxWindow *arg1 = (wxWindow *) 0 ;
29734 wxPoint *arg2 = 0 ;
29735 wxPoint result;
29736 wxPoint temp2 ;
29737 PyObject * obj0 = 0 ;
29738 PyObject * obj1 = 0 ;
29739 char *kwnames[] = {
29740 (char *) "self",(char *) "pt", NULL
29741 };
29742
29743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
29744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29745 if (SWIG_arg_fail(1)) SWIG_fail;
29746 {
29747 arg2 = &temp2;
29748 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29749 }
29750 {
29751 PyThreadState* __tstate = wxPyBeginAllowThreads();
29752 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29753
29754 wxPyEndAllowThreads(__tstate);
29755 if (PyErr_Occurred()) SWIG_fail;
29756 }
29757 {
29758 wxPoint * resultptr;
29759 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29760 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29761 }
29762 return resultobj;
29763 fail:
29764 return NULL;
29765 }
29766
29767
29768 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
29769 PyObject *resultobj = NULL;
29770 wxWindow *arg1 = (wxWindow *) 0 ;
29771 wxSize *arg2 = 0 ;
29772 wxSize result;
29773 wxSize temp2 ;
29774 PyObject * obj0 = 0 ;
29775 PyObject * obj1 = 0 ;
29776 char *kwnames[] = {
29777 (char *) "self",(char *) "sz", NULL
29778 };
29779
29780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29782 if (SWIG_arg_fail(1)) SWIG_fail;
29783 {
29784 arg2 = &temp2;
29785 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29786 }
29787 {
29788 PyThreadState* __tstate = wxPyBeginAllowThreads();
29789 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29790
29791 wxPyEndAllowThreads(__tstate);
29792 if (PyErr_Occurred()) SWIG_fail;
29793 }
29794 {
29795 wxSize * resultptr;
29796 resultptr = new wxSize(static_cast<wxSize & >(result));
29797 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29798 }
29799 return resultobj;
29800 fail:
29801 return NULL;
29802 }
29803
29804
29805 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29806 PyObject *resultobj = NULL;
29807 wxWindow *arg1 = (wxWindow *) 0 ;
29808 wxPoint *arg2 = 0 ;
29809 wxPoint result;
29810 wxPoint temp2 ;
29811 PyObject * obj0 = 0 ;
29812 PyObject * obj1 = 0 ;
29813 char *kwnames[] = {
29814 (char *) "self",(char *) "pt", NULL
29815 };
29816
29817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29819 if (SWIG_arg_fail(1)) SWIG_fail;
29820 {
29821 arg2 = &temp2;
29822 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29823 }
29824 {
29825 PyThreadState* __tstate = wxPyBeginAllowThreads();
29826 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29827
29828 wxPyEndAllowThreads(__tstate);
29829 if (PyErr_Occurred()) SWIG_fail;
29830 }
29831 {
29832 wxPoint * resultptr;
29833 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29834 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29835 }
29836 return resultobj;
29837 fail:
29838 return NULL;
29839 }
29840
29841
29842 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29843 PyObject *resultobj = NULL;
29844 wxWindow *arg1 = (wxWindow *) 0 ;
29845 wxSize *arg2 = 0 ;
29846 wxSize result;
29847 wxSize temp2 ;
29848 PyObject * obj0 = 0 ;
29849 PyObject * obj1 = 0 ;
29850 char *kwnames[] = {
29851 (char *) "self",(char *) "sz", NULL
29852 };
29853
29854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29856 if (SWIG_arg_fail(1)) SWIG_fail;
29857 {
29858 arg2 = &temp2;
29859 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29860 }
29861 {
29862 PyThreadState* __tstate = wxPyBeginAllowThreads();
29863 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29864
29865 wxPyEndAllowThreads(__tstate);
29866 if (PyErr_Occurred()) SWIG_fail;
29867 }
29868 {
29869 wxSize * resultptr;
29870 resultptr = new wxSize(static_cast<wxSize & >(result));
29871 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29872 }
29873 return resultobj;
29874 fail:
29875 return NULL;
29876 }
29877
29878
29879 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29880 PyObject *resultobj = NULL;
29881 wxWindow *arg1 = (wxWindow *) 0 ;
29882 int arg2 ;
29883 int arg3 ;
29884 PyObject * obj0 = 0 ;
29885 PyObject * obj1 = 0 ;
29886 PyObject * obj2 = 0 ;
29887 char *kwnames[] = {
29888 (char *) "self",(char *) "x",(char *) "y", NULL
29889 };
29890
29891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29893 if (SWIG_arg_fail(1)) SWIG_fail;
29894 {
29895 arg2 = static_cast<int >(SWIG_As_int(obj1));
29896 if (SWIG_arg_fail(2)) SWIG_fail;
29897 }
29898 {
29899 arg3 = static_cast<int >(SWIG_As_int(obj2));
29900 if (SWIG_arg_fail(3)) SWIG_fail;
29901 }
29902 {
29903 PyThreadState* __tstate = wxPyBeginAllowThreads();
29904 (arg1)->WarpPointer(arg2,arg3);
29905
29906 wxPyEndAllowThreads(__tstate);
29907 if (PyErr_Occurred()) SWIG_fail;
29908 }
29909 Py_INCREF(Py_None); resultobj = Py_None;
29910 return resultobj;
29911 fail:
29912 return NULL;
29913 }
29914
29915
29916 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29917 PyObject *resultobj = NULL;
29918 wxWindow *arg1 = (wxWindow *) 0 ;
29919 PyObject * obj0 = 0 ;
29920 char *kwnames[] = {
29921 (char *) "self", NULL
29922 };
29923
29924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29926 if (SWIG_arg_fail(1)) SWIG_fail;
29927 {
29928 PyThreadState* __tstate = wxPyBeginAllowThreads();
29929 (arg1)->CaptureMouse();
29930
29931 wxPyEndAllowThreads(__tstate);
29932 if (PyErr_Occurred()) SWIG_fail;
29933 }
29934 Py_INCREF(Py_None); resultobj = Py_None;
29935 return resultobj;
29936 fail:
29937 return NULL;
29938 }
29939
29940
29941 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29942 PyObject *resultobj = NULL;
29943 wxWindow *arg1 = (wxWindow *) 0 ;
29944 PyObject * obj0 = 0 ;
29945 char *kwnames[] = {
29946 (char *) "self", NULL
29947 };
29948
29949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29951 if (SWIG_arg_fail(1)) SWIG_fail;
29952 {
29953 PyThreadState* __tstate = wxPyBeginAllowThreads();
29954 (arg1)->ReleaseMouse();
29955
29956 wxPyEndAllowThreads(__tstate);
29957 if (PyErr_Occurred()) SWIG_fail;
29958 }
29959 Py_INCREF(Py_None); resultobj = Py_None;
29960 return resultobj;
29961 fail:
29962 return NULL;
29963 }
29964
29965
29966 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29967 PyObject *resultobj = NULL;
29968 wxWindow *result;
29969 char *kwnames[] = {
29970 NULL
29971 };
29972
29973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29974 {
29975 if (!wxPyCheckForApp()) SWIG_fail;
29976 PyThreadState* __tstate = wxPyBeginAllowThreads();
29977 result = (wxWindow *)wxWindow::GetCapture();
29978
29979 wxPyEndAllowThreads(__tstate);
29980 if (PyErr_Occurred()) SWIG_fail;
29981 }
29982 {
29983 resultobj = wxPyMake_wxObject(result, 0);
29984 }
29985 return resultobj;
29986 fail:
29987 return NULL;
29988 }
29989
29990
29991 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29992 PyObject *resultobj = NULL;
29993 wxWindow *arg1 = (wxWindow *) 0 ;
29994 bool result;
29995 PyObject * obj0 = 0 ;
29996 char *kwnames[] = {
29997 (char *) "self", NULL
29998 };
29999
30000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
30001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30002 if (SWIG_arg_fail(1)) SWIG_fail;
30003 {
30004 PyThreadState* __tstate = wxPyBeginAllowThreads();
30005 result = (bool)((wxWindow const *)arg1)->HasCapture();
30006
30007 wxPyEndAllowThreads(__tstate);
30008 if (PyErr_Occurred()) SWIG_fail;
30009 }
30010 {
30011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30012 }
30013 return resultobj;
30014 fail:
30015 return NULL;
30016 }
30017
30018
30019 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
30020 PyObject *resultobj = NULL;
30021 wxWindow *arg1 = (wxWindow *) 0 ;
30022 bool arg2 = (bool) true ;
30023 wxRect *arg3 = (wxRect *) NULL ;
30024 PyObject * obj0 = 0 ;
30025 PyObject * obj1 = 0 ;
30026 PyObject * obj2 = 0 ;
30027 char *kwnames[] = {
30028 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
30029 };
30030
30031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
30032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30033 if (SWIG_arg_fail(1)) SWIG_fail;
30034 if (obj1) {
30035 {
30036 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
30037 if (SWIG_arg_fail(2)) SWIG_fail;
30038 }
30039 }
30040 if (obj2) {
30041 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30042 if (SWIG_arg_fail(3)) SWIG_fail;
30043 }
30044 {
30045 PyThreadState* __tstate = wxPyBeginAllowThreads();
30046 (arg1)->Refresh(arg2,(wxRect const *)arg3);
30047
30048 wxPyEndAllowThreads(__tstate);
30049 if (PyErr_Occurred()) SWIG_fail;
30050 }
30051 Py_INCREF(Py_None); resultobj = Py_None;
30052 return resultobj;
30053 fail:
30054 return NULL;
30055 }
30056
30057
30058 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
30059 PyObject *resultobj = NULL;
30060 wxWindow *arg1 = (wxWindow *) 0 ;
30061 wxRect *arg2 = 0 ;
30062 bool arg3 = (bool) true ;
30063 wxRect temp2 ;
30064 PyObject * obj0 = 0 ;
30065 PyObject * obj1 = 0 ;
30066 PyObject * obj2 = 0 ;
30067 char *kwnames[] = {
30068 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
30069 };
30070
30071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
30072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30073 if (SWIG_arg_fail(1)) SWIG_fail;
30074 {
30075 arg2 = &temp2;
30076 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30077 }
30078 if (obj2) {
30079 {
30080 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
30081 if (SWIG_arg_fail(3)) SWIG_fail;
30082 }
30083 }
30084 {
30085 PyThreadState* __tstate = wxPyBeginAllowThreads();
30086 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
30087
30088 wxPyEndAllowThreads(__tstate);
30089 if (PyErr_Occurred()) SWIG_fail;
30090 }
30091 Py_INCREF(Py_None); resultobj = Py_None;
30092 return resultobj;
30093 fail:
30094 return NULL;
30095 }
30096
30097
30098 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
30099 PyObject *resultobj = NULL;
30100 wxWindow *arg1 = (wxWindow *) 0 ;
30101 PyObject * obj0 = 0 ;
30102 char *kwnames[] = {
30103 (char *) "self", NULL
30104 };
30105
30106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
30107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30108 if (SWIG_arg_fail(1)) SWIG_fail;
30109 {
30110 PyThreadState* __tstate = wxPyBeginAllowThreads();
30111 (arg1)->Update();
30112
30113 wxPyEndAllowThreads(__tstate);
30114 if (PyErr_Occurred()) SWIG_fail;
30115 }
30116 Py_INCREF(Py_None); resultobj = Py_None;
30117 return resultobj;
30118 fail:
30119 return NULL;
30120 }
30121
30122
30123 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30124 PyObject *resultobj = NULL;
30125 wxWindow *arg1 = (wxWindow *) 0 ;
30126 PyObject * obj0 = 0 ;
30127 char *kwnames[] = {
30128 (char *) "self", NULL
30129 };
30130
30131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
30132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30133 if (SWIG_arg_fail(1)) SWIG_fail;
30134 {
30135 PyThreadState* __tstate = wxPyBeginAllowThreads();
30136 (arg1)->ClearBackground();
30137
30138 wxPyEndAllowThreads(__tstate);
30139 if (PyErr_Occurred()) SWIG_fail;
30140 }
30141 Py_INCREF(Py_None); resultobj = Py_None;
30142 return resultobj;
30143 fail:
30144 return NULL;
30145 }
30146
30147
30148 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
30149 PyObject *resultobj = NULL;
30150 wxWindow *arg1 = (wxWindow *) 0 ;
30151 PyObject * obj0 = 0 ;
30152 char *kwnames[] = {
30153 (char *) "self", NULL
30154 };
30155
30156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
30157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30158 if (SWIG_arg_fail(1)) SWIG_fail;
30159 {
30160 PyThreadState* __tstate = wxPyBeginAllowThreads();
30161 (arg1)->Freeze();
30162
30163 wxPyEndAllowThreads(__tstate);
30164 if (PyErr_Occurred()) SWIG_fail;
30165 }
30166 Py_INCREF(Py_None); resultobj = Py_None;
30167 return resultobj;
30168 fail:
30169 return NULL;
30170 }
30171
30172
30173 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
30174 PyObject *resultobj = NULL;
30175 wxWindow *arg1 = (wxWindow *) 0 ;
30176 PyObject * obj0 = 0 ;
30177 char *kwnames[] = {
30178 (char *) "self", NULL
30179 };
30180
30181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
30182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30183 if (SWIG_arg_fail(1)) SWIG_fail;
30184 {
30185 PyThreadState* __tstate = wxPyBeginAllowThreads();
30186 (arg1)->Thaw();
30187
30188 wxPyEndAllowThreads(__tstate);
30189 if (PyErr_Occurred()) SWIG_fail;
30190 }
30191 Py_INCREF(Py_None); resultobj = Py_None;
30192 return resultobj;
30193 fail:
30194 return NULL;
30195 }
30196
30197
30198 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
30199 PyObject *resultobj = NULL;
30200 wxWindow *arg1 = (wxWindow *) 0 ;
30201 wxDC *arg2 = 0 ;
30202 PyObject * obj0 = 0 ;
30203 PyObject * obj1 = 0 ;
30204 char *kwnames[] = {
30205 (char *) "self",(char *) "dc", NULL
30206 };
30207
30208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
30209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30210 if (SWIG_arg_fail(1)) SWIG_fail;
30211 {
30212 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
30213 if (SWIG_arg_fail(2)) SWIG_fail;
30214 if (arg2 == NULL) {
30215 SWIG_null_ref("wxDC");
30216 }
30217 if (SWIG_arg_fail(2)) SWIG_fail;
30218 }
30219 {
30220 PyThreadState* __tstate = wxPyBeginAllowThreads();
30221 (arg1)->PrepareDC(*arg2);
30222
30223 wxPyEndAllowThreads(__tstate);
30224 if (PyErr_Occurred()) SWIG_fail;
30225 }
30226 Py_INCREF(Py_None); resultobj = Py_None;
30227 return resultobj;
30228 fail:
30229 return NULL;
30230 }
30231
30232
30233 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
30234 PyObject *resultobj = NULL;
30235 wxWindow *arg1 = (wxWindow *) 0 ;
30236 wxRegion *result;
30237 PyObject * obj0 = 0 ;
30238 char *kwnames[] = {
30239 (char *) "self", NULL
30240 };
30241
30242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
30243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30244 if (SWIG_arg_fail(1)) SWIG_fail;
30245 {
30246 PyThreadState* __tstate = wxPyBeginAllowThreads();
30247 {
30248 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
30249 result = (wxRegion *) &_result_ref;
30250 }
30251
30252 wxPyEndAllowThreads(__tstate);
30253 if (PyErr_Occurred()) SWIG_fail;
30254 }
30255 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
30256 return resultobj;
30257 fail:
30258 return NULL;
30259 }
30260
30261
30262 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
30263 PyObject *resultobj = NULL;
30264 wxWindow *arg1 = (wxWindow *) 0 ;
30265 wxRect result;
30266 PyObject * obj0 = 0 ;
30267 char *kwnames[] = {
30268 (char *) "self", NULL
30269 };
30270
30271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
30272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30273 if (SWIG_arg_fail(1)) SWIG_fail;
30274 {
30275 PyThreadState* __tstate = wxPyBeginAllowThreads();
30276 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
30277
30278 wxPyEndAllowThreads(__tstate);
30279 if (PyErr_Occurred()) SWIG_fail;
30280 }
30281 {
30282 wxRect * resultptr;
30283 resultptr = new wxRect(static_cast<wxRect & >(result));
30284 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30285 }
30286 return resultobj;
30287 fail:
30288 return NULL;
30289 }
30290
30291
30292 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
30293 PyObject *resultobj = NULL;
30294 wxWindow *arg1 = (wxWindow *) 0 ;
30295 int arg2 ;
30296 int arg3 ;
30297 int arg4 = (int) 1 ;
30298 int arg5 = (int) 1 ;
30299 bool result;
30300 PyObject * obj0 = 0 ;
30301 PyObject * obj1 = 0 ;
30302 PyObject * obj2 = 0 ;
30303 PyObject * obj3 = 0 ;
30304 PyObject * obj4 = 0 ;
30305 char *kwnames[] = {
30306 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
30307 };
30308
30309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
30310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30311 if (SWIG_arg_fail(1)) SWIG_fail;
30312 {
30313 arg2 = static_cast<int >(SWIG_As_int(obj1));
30314 if (SWIG_arg_fail(2)) SWIG_fail;
30315 }
30316 {
30317 arg3 = static_cast<int >(SWIG_As_int(obj2));
30318 if (SWIG_arg_fail(3)) SWIG_fail;
30319 }
30320 if (obj3) {
30321 {
30322 arg4 = static_cast<int >(SWIG_As_int(obj3));
30323 if (SWIG_arg_fail(4)) SWIG_fail;
30324 }
30325 }
30326 if (obj4) {
30327 {
30328 arg5 = static_cast<int >(SWIG_As_int(obj4));
30329 if (SWIG_arg_fail(5)) SWIG_fail;
30330 }
30331 }
30332 {
30333 PyThreadState* __tstate = wxPyBeginAllowThreads();
30334 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
30335
30336 wxPyEndAllowThreads(__tstate);
30337 if (PyErr_Occurred()) SWIG_fail;
30338 }
30339 {
30340 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30341 }
30342 return resultobj;
30343 fail:
30344 return NULL;
30345 }
30346
30347
30348 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30349 PyObject *resultobj = NULL;
30350 wxWindow *arg1 = (wxWindow *) 0 ;
30351 wxPoint *arg2 = 0 ;
30352 bool result;
30353 wxPoint temp2 ;
30354 PyObject * obj0 = 0 ;
30355 PyObject * obj1 = 0 ;
30356 char *kwnames[] = {
30357 (char *) "self",(char *) "pt", NULL
30358 };
30359
30360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
30361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30362 if (SWIG_arg_fail(1)) SWIG_fail;
30363 {
30364 arg2 = &temp2;
30365 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30366 }
30367 {
30368 PyThreadState* __tstate = wxPyBeginAllowThreads();
30369 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
30370
30371 wxPyEndAllowThreads(__tstate);
30372 if (PyErr_Occurred()) SWIG_fail;
30373 }
30374 {
30375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30376 }
30377 return resultobj;
30378 fail:
30379 return NULL;
30380 }
30381
30382
30383 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
30384 PyObject *resultobj = NULL;
30385 wxWindow *arg1 = (wxWindow *) 0 ;
30386 wxRect *arg2 = 0 ;
30387 bool result;
30388 wxRect temp2 ;
30389 PyObject * obj0 = 0 ;
30390 PyObject * obj1 = 0 ;
30391 char *kwnames[] = {
30392 (char *) "self",(char *) "rect", NULL
30393 };
30394
30395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
30396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30397 if (SWIG_arg_fail(1)) SWIG_fail;
30398 {
30399 arg2 = &temp2;
30400 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30401 }
30402 {
30403 PyThreadState* __tstate = wxPyBeginAllowThreads();
30404 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
30405
30406 wxPyEndAllowThreads(__tstate);
30407 if (PyErr_Occurred()) SWIG_fail;
30408 }
30409 {
30410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30411 }
30412 return resultobj;
30413 fail:
30414 return NULL;
30415 }
30416
30417
30418 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30419 PyObject *resultobj = NULL;
30420 wxWindow *arg1 = (wxWindow *) 0 ;
30421 wxVisualAttributes result;
30422 PyObject * obj0 = 0 ;
30423 char *kwnames[] = {
30424 (char *) "self", NULL
30425 };
30426
30427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
30428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30429 if (SWIG_arg_fail(1)) SWIG_fail;
30430 {
30431 PyThreadState* __tstate = wxPyBeginAllowThreads();
30432 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
30433
30434 wxPyEndAllowThreads(__tstate);
30435 if (PyErr_Occurred()) SWIG_fail;
30436 }
30437 {
30438 wxVisualAttributes * resultptr;
30439 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
30440 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30441 }
30442 return resultobj;
30443 fail:
30444 return NULL;
30445 }
30446
30447
30448 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30449 PyObject *resultobj = NULL;
30450 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
30451 wxVisualAttributes result;
30452 PyObject * obj0 = 0 ;
30453 char *kwnames[] = {
30454 (char *) "variant", NULL
30455 };
30456
30457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
30458 if (obj0) {
30459 {
30460 arg1 = static_cast<wxWindowVariant >(SWIG_As_int(obj0));
30461 if (SWIG_arg_fail(1)) SWIG_fail;
30462 }
30463 }
30464 {
30465 if (!wxPyCheckForApp()) SWIG_fail;
30466 PyThreadState* __tstate = wxPyBeginAllowThreads();
30467 result = wxWindow::GetClassDefaultAttributes(arg1);
30468
30469 wxPyEndAllowThreads(__tstate);
30470 if (PyErr_Occurred()) SWIG_fail;
30471 }
30472 {
30473 wxVisualAttributes * resultptr;
30474 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
30475 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30476 }
30477 return resultobj;
30478 fail:
30479 return NULL;
30480 }
30481
30482
30483 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30484 PyObject *resultobj = NULL;
30485 wxWindow *arg1 = (wxWindow *) 0 ;
30486 wxColour *arg2 = 0 ;
30487 bool result;
30488 wxColour temp2 ;
30489 PyObject * obj0 = 0 ;
30490 PyObject * obj1 = 0 ;
30491 char *kwnames[] = {
30492 (char *) "self",(char *) "colour", NULL
30493 };
30494
30495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30497 if (SWIG_arg_fail(1)) SWIG_fail;
30498 {
30499 arg2 = &temp2;
30500 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30501 }
30502 {
30503 PyThreadState* __tstate = wxPyBeginAllowThreads();
30504 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
30505
30506 wxPyEndAllowThreads(__tstate);
30507 if (PyErr_Occurred()) SWIG_fail;
30508 }
30509 {
30510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30511 }
30512 return resultobj;
30513 fail:
30514 return NULL;
30515 }
30516
30517
30518 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30519 PyObject *resultobj = NULL;
30520 wxWindow *arg1 = (wxWindow *) 0 ;
30521 wxColour *arg2 = 0 ;
30522 wxColour temp2 ;
30523 PyObject * obj0 = 0 ;
30524 PyObject * obj1 = 0 ;
30525 char *kwnames[] = {
30526 (char *) "self",(char *) "colour", NULL
30527 };
30528
30529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30531 if (SWIG_arg_fail(1)) SWIG_fail;
30532 {
30533 arg2 = &temp2;
30534 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30535 }
30536 {
30537 PyThreadState* __tstate = wxPyBeginAllowThreads();
30538 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
30539
30540 wxPyEndAllowThreads(__tstate);
30541 if (PyErr_Occurred()) SWIG_fail;
30542 }
30543 Py_INCREF(Py_None); resultobj = Py_None;
30544 return resultobj;
30545 fail:
30546 return NULL;
30547 }
30548
30549
30550 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30551 PyObject *resultobj = NULL;
30552 wxWindow *arg1 = (wxWindow *) 0 ;
30553 wxColour *arg2 = 0 ;
30554 bool result;
30555 wxColour temp2 ;
30556 PyObject * obj0 = 0 ;
30557 PyObject * obj1 = 0 ;
30558 char *kwnames[] = {
30559 (char *) "self",(char *) "colour", NULL
30560 };
30561
30562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30564 if (SWIG_arg_fail(1)) SWIG_fail;
30565 {
30566 arg2 = &temp2;
30567 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30568 }
30569 {
30570 PyThreadState* __tstate = wxPyBeginAllowThreads();
30571 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
30572
30573 wxPyEndAllowThreads(__tstate);
30574 if (PyErr_Occurred()) SWIG_fail;
30575 }
30576 {
30577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30578 }
30579 return resultobj;
30580 fail:
30581 return NULL;
30582 }
30583
30584
30585 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30586 PyObject *resultobj = NULL;
30587 wxWindow *arg1 = (wxWindow *) 0 ;
30588 wxColour *arg2 = 0 ;
30589 wxColour temp2 ;
30590 PyObject * obj0 = 0 ;
30591 PyObject * obj1 = 0 ;
30592 char *kwnames[] = {
30593 (char *) "self",(char *) "colour", NULL
30594 };
30595
30596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30598 if (SWIG_arg_fail(1)) SWIG_fail;
30599 {
30600 arg2 = &temp2;
30601 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30602 }
30603 {
30604 PyThreadState* __tstate = wxPyBeginAllowThreads();
30605 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
30606
30607 wxPyEndAllowThreads(__tstate);
30608 if (PyErr_Occurred()) SWIG_fail;
30609 }
30610 Py_INCREF(Py_None); resultobj = Py_None;
30611 return resultobj;
30612 fail:
30613 return NULL;
30614 }
30615
30616
30617 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30618 PyObject *resultobj = NULL;
30619 wxWindow *arg1 = (wxWindow *) 0 ;
30620 wxColour result;
30621 PyObject * obj0 = 0 ;
30622 char *kwnames[] = {
30623 (char *) "self", NULL
30624 };
30625
30626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
30627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30628 if (SWIG_arg_fail(1)) SWIG_fail;
30629 {
30630 PyThreadState* __tstate = wxPyBeginAllowThreads();
30631 result = ((wxWindow const *)arg1)->GetBackgroundColour();
30632
30633 wxPyEndAllowThreads(__tstate);
30634 if (PyErr_Occurred()) SWIG_fail;
30635 }
30636 {
30637 wxColour * resultptr;
30638 resultptr = new wxColour(static_cast<wxColour & >(result));
30639 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30640 }
30641 return resultobj;
30642 fail:
30643 return NULL;
30644 }
30645
30646
30647 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30648 PyObject *resultobj = NULL;
30649 wxWindow *arg1 = (wxWindow *) 0 ;
30650 wxColour result;
30651 PyObject * obj0 = 0 ;
30652 char *kwnames[] = {
30653 (char *) "self", NULL
30654 };
30655
30656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
30657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30658 if (SWIG_arg_fail(1)) SWIG_fail;
30659 {
30660 PyThreadState* __tstate = wxPyBeginAllowThreads();
30661 result = ((wxWindow const *)arg1)->GetForegroundColour();
30662
30663 wxPyEndAllowThreads(__tstate);
30664 if (PyErr_Occurred()) SWIG_fail;
30665 }
30666 {
30667 wxColour * resultptr;
30668 resultptr = new wxColour(static_cast<wxColour & >(result));
30669 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30670 }
30671 return resultobj;
30672 fail:
30673 return NULL;
30674 }
30675
30676
30677 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30678 PyObject *resultobj = NULL;
30679 wxWindow *arg1 = (wxWindow *) 0 ;
30680 bool result;
30681 PyObject * obj0 = 0 ;
30682 char *kwnames[] = {
30683 (char *) "self", NULL
30684 };
30685
30686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
30687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30688 if (SWIG_arg_fail(1)) SWIG_fail;
30689 {
30690 PyThreadState* __tstate = wxPyBeginAllowThreads();
30691 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
30692
30693 wxPyEndAllowThreads(__tstate);
30694 if (PyErr_Occurred()) SWIG_fail;
30695 }
30696 {
30697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30698 }
30699 return resultobj;
30700 fail:
30701 return NULL;
30702 }
30703
30704
30705 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
30706 PyObject *resultobj = NULL;
30707 wxWindow *arg1 = (wxWindow *) 0 ;
30708 bool result;
30709 PyObject * obj0 = 0 ;
30710 char *kwnames[] = {
30711 (char *) "self", NULL
30712 };
30713
30714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
30715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30716 if (SWIG_arg_fail(1)) SWIG_fail;
30717 {
30718 PyThreadState* __tstate = wxPyBeginAllowThreads();
30719 result = (bool)((wxWindow const *)arg1)->UseBgCol();
30720
30721 wxPyEndAllowThreads(__tstate);
30722 if (PyErr_Occurred()) SWIG_fail;
30723 }
30724 {
30725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30726 }
30727 return resultobj;
30728 fail:
30729 return NULL;
30730 }
30731
30732
30733 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30734 PyObject *resultobj = NULL;
30735 wxWindow *arg1 = (wxWindow *) 0 ;
30736 wxBackgroundStyle arg2 ;
30737 bool result;
30738 PyObject * obj0 = 0 ;
30739 PyObject * obj1 = 0 ;
30740 char *kwnames[] = {
30741 (char *) "self",(char *) "style", NULL
30742 };
30743
30744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
30745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30746 if (SWIG_arg_fail(1)) SWIG_fail;
30747 {
30748 arg2 = static_cast<wxBackgroundStyle >(SWIG_As_int(obj1));
30749 if (SWIG_arg_fail(2)) SWIG_fail;
30750 }
30751 {
30752 PyThreadState* __tstate = wxPyBeginAllowThreads();
30753 result = (bool)(arg1)->SetBackgroundStyle(arg2);
30754
30755 wxPyEndAllowThreads(__tstate);
30756 if (PyErr_Occurred()) SWIG_fail;
30757 }
30758 {
30759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30760 }
30761 return resultobj;
30762 fail:
30763 return NULL;
30764 }
30765
30766
30767 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30768 PyObject *resultobj = NULL;
30769 wxWindow *arg1 = (wxWindow *) 0 ;
30770 wxBackgroundStyle result;
30771 PyObject * obj0 = 0 ;
30772 char *kwnames[] = {
30773 (char *) "self", NULL
30774 };
30775
30776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
30777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30778 if (SWIG_arg_fail(1)) SWIG_fail;
30779 {
30780 PyThreadState* __tstate = wxPyBeginAllowThreads();
30781 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30782
30783 wxPyEndAllowThreads(__tstate);
30784 if (PyErr_Occurred()) SWIG_fail;
30785 }
30786 resultobj = SWIG_From_int((result));
30787 return resultobj;
30788 fail:
30789 return NULL;
30790 }
30791
30792
30793 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30794 PyObject *resultobj = NULL;
30795 wxWindow *arg1 = (wxWindow *) 0 ;
30796 bool result;
30797 PyObject * obj0 = 0 ;
30798 char *kwnames[] = {
30799 (char *) "self", NULL
30800 };
30801
30802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30804 if (SWIG_arg_fail(1)) SWIG_fail;
30805 {
30806 PyThreadState* __tstate = wxPyBeginAllowThreads();
30807 result = (bool)(arg1)->HasTransparentBackground();
30808
30809 wxPyEndAllowThreads(__tstate);
30810 if (PyErr_Occurred()) SWIG_fail;
30811 }
30812 {
30813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30814 }
30815 return resultobj;
30816 fail:
30817 return NULL;
30818 }
30819
30820
30821 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30822 PyObject *resultobj = NULL;
30823 wxWindow *arg1 = (wxWindow *) 0 ;
30824 wxCursor *arg2 = 0 ;
30825 bool result;
30826 PyObject * obj0 = 0 ;
30827 PyObject * obj1 = 0 ;
30828 char *kwnames[] = {
30829 (char *) "self",(char *) "cursor", NULL
30830 };
30831
30832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30834 if (SWIG_arg_fail(1)) SWIG_fail;
30835 {
30836 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30837 if (SWIG_arg_fail(2)) SWIG_fail;
30838 if (arg2 == NULL) {
30839 SWIG_null_ref("wxCursor");
30840 }
30841 if (SWIG_arg_fail(2)) SWIG_fail;
30842 }
30843 {
30844 PyThreadState* __tstate = wxPyBeginAllowThreads();
30845 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30846
30847 wxPyEndAllowThreads(__tstate);
30848 if (PyErr_Occurred()) SWIG_fail;
30849 }
30850 {
30851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30852 }
30853 return resultobj;
30854 fail:
30855 return NULL;
30856 }
30857
30858
30859 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30860 PyObject *resultobj = NULL;
30861 wxWindow *arg1 = (wxWindow *) 0 ;
30862 wxCursor result;
30863 PyObject * obj0 = 0 ;
30864 char *kwnames[] = {
30865 (char *) "self", NULL
30866 };
30867
30868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30870 if (SWIG_arg_fail(1)) SWIG_fail;
30871 {
30872 PyThreadState* __tstate = wxPyBeginAllowThreads();
30873 result = (arg1)->GetCursor();
30874
30875 wxPyEndAllowThreads(__tstate);
30876 if (PyErr_Occurred()) SWIG_fail;
30877 }
30878 {
30879 wxCursor * resultptr;
30880 resultptr = new wxCursor(static_cast<wxCursor & >(result));
30881 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30882 }
30883 return resultobj;
30884 fail:
30885 return NULL;
30886 }
30887
30888
30889 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30890 PyObject *resultobj = NULL;
30891 wxWindow *arg1 = (wxWindow *) 0 ;
30892 wxFont *arg2 = 0 ;
30893 bool result;
30894 PyObject * obj0 = 0 ;
30895 PyObject * obj1 = 0 ;
30896 char *kwnames[] = {
30897 (char *) "self",(char *) "font", NULL
30898 };
30899
30900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30902 if (SWIG_arg_fail(1)) SWIG_fail;
30903 {
30904 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30905 if (SWIG_arg_fail(2)) SWIG_fail;
30906 if (arg2 == NULL) {
30907 SWIG_null_ref("wxFont");
30908 }
30909 if (SWIG_arg_fail(2)) SWIG_fail;
30910 }
30911 {
30912 PyThreadState* __tstate = wxPyBeginAllowThreads();
30913 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30914
30915 wxPyEndAllowThreads(__tstate);
30916 if (PyErr_Occurred()) SWIG_fail;
30917 }
30918 {
30919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30920 }
30921 return resultobj;
30922 fail:
30923 return NULL;
30924 }
30925
30926
30927 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30928 PyObject *resultobj = NULL;
30929 wxWindow *arg1 = (wxWindow *) 0 ;
30930 wxFont *arg2 = 0 ;
30931 PyObject * obj0 = 0 ;
30932 PyObject * obj1 = 0 ;
30933 char *kwnames[] = {
30934 (char *) "self",(char *) "font", NULL
30935 };
30936
30937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30939 if (SWIG_arg_fail(1)) SWIG_fail;
30940 {
30941 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30942 if (SWIG_arg_fail(2)) SWIG_fail;
30943 if (arg2 == NULL) {
30944 SWIG_null_ref("wxFont");
30945 }
30946 if (SWIG_arg_fail(2)) SWIG_fail;
30947 }
30948 {
30949 PyThreadState* __tstate = wxPyBeginAllowThreads();
30950 (arg1)->SetOwnFont((wxFont const &)*arg2);
30951
30952 wxPyEndAllowThreads(__tstate);
30953 if (PyErr_Occurred()) SWIG_fail;
30954 }
30955 Py_INCREF(Py_None); resultobj = Py_None;
30956 return resultobj;
30957 fail:
30958 return NULL;
30959 }
30960
30961
30962 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30963 PyObject *resultobj = NULL;
30964 wxWindow *arg1 = (wxWindow *) 0 ;
30965 wxFont result;
30966 PyObject * obj0 = 0 ;
30967 char *kwnames[] = {
30968 (char *) "self", NULL
30969 };
30970
30971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30973 if (SWIG_arg_fail(1)) SWIG_fail;
30974 {
30975 PyThreadState* __tstate = wxPyBeginAllowThreads();
30976 result = (arg1)->GetFont();
30977
30978 wxPyEndAllowThreads(__tstate);
30979 if (PyErr_Occurred()) SWIG_fail;
30980 }
30981 {
30982 wxFont * resultptr;
30983 resultptr = new wxFont(static_cast<wxFont & >(result));
30984 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30985 }
30986 return resultobj;
30987 fail:
30988 return NULL;
30989 }
30990
30991
30992 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30993 PyObject *resultobj = NULL;
30994 wxWindow *arg1 = (wxWindow *) 0 ;
30995 wxCaret *arg2 = (wxCaret *) 0 ;
30996 PyObject * obj0 = 0 ;
30997 PyObject * obj1 = 0 ;
30998 char *kwnames[] = {
30999 (char *) "self",(char *) "caret", NULL
31000 };
31001
31002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
31003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31004 if (SWIG_arg_fail(1)) SWIG_fail;
31005 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
31006 if (SWIG_arg_fail(2)) SWIG_fail;
31007 {
31008 PyThreadState* __tstate = wxPyBeginAllowThreads();
31009 (arg1)->SetCaret(arg2);
31010
31011 wxPyEndAllowThreads(__tstate);
31012 if (PyErr_Occurred()) SWIG_fail;
31013 }
31014 Py_INCREF(Py_None); resultobj = Py_None;
31015 return resultobj;
31016 fail:
31017 return NULL;
31018 }
31019
31020
31021 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
31022 PyObject *resultobj = NULL;
31023 wxWindow *arg1 = (wxWindow *) 0 ;
31024 wxCaret *result;
31025 PyObject * obj0 = 0 ;
31026 char *kwnames[] = {
31027 (char *) "self", NULL
31028 };
31029
31030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
31031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31032 if (SWIG_arg_fail(1)) SWIG_fail;
31033 {
31034 PyThreadState* __tstate = wxPyBeginAllowThreads();
31035 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
31036
31037 wxPyEndAllowThreads(__tstate);
31038 if (PyErr_Occurred()) SWIG_fail;
31039 }
31040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
31041 return resultobj;
31042 fail:
31043 return NULL;
31044 }
31045
31046
31047 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
31048 PyObject *resultobj = NULL;
31049 wxWindow *arg1 = (wxWindow *) 0 ;
31050 int result;
31051 PyObject * obj0 = 0 ;
31052 char *kwnames[] = {
31053 (char *) "self", NULL
31054 };
31055
31056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
31057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31058 if (SWIG_arg_fail(1)) SWIG_fail;
31059 {
31060 PyThreadState* __tstate = wxPyBeginAllowThreads();
31061 result = (int)((wxWindow const *)arg1)->GetCharHeight();
31062
31063 wxPyEndAllowThreads(__tstate);
31064 if (PyErr_Occurred()) SWIG_fail;
31065 }
31066 {
31067 resultobj = SWIG_From_int(static_cast<int >(result));
31068 }
31069 return resultobj;
31070 fail:
31071 return NULL;
31072 }
31073
31074
31075 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
31076 PyObject *resultobj = NULL;
31077 wxWindow *arg1 = (wxWindow *) 0 ;
31078 int result;
31079 PyObject * obj0 = 0 ;
31080 char *kwnames[] = {
31081 (char *) "self", NULL
31082 };
31083
31084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
31085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31086 if (SWIG_arg_fail(1)) SWIG_fail;
31087 {
31088 PyThreadState* __tstate = wxPyBeginAllowThreads();
31089 result = (int)((wxWindow const *)arg1)->GetCharWidth();
31090
31091 wxPyEndAllowThreads(__tstate);
31092 if (PyErr_Occurred()) SWIG_fail;
31093 }
31094 {
31095 resultobj = SWIG_From_int(static_cast<int >(result));
31096 }
31097 return resultobj;
31098 fail:
31099 return NULL;
31100 }
31101
31102
31103 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
31104 PyObject *resultobj = NULL;
31105 wxWindow *arg1 = (wxWindow *) 0 ;
31106 wxString *arg2 = 0 ;
31107 int *arg3 = (int *) 0 ;
31108 int *arg4 = (int *) 0 ;
31109 bool temp2 = false ;
31110 int temp3 ;
31111 int res3 = 0 ;
31112 int temp4 ;
31113 int res4 = 0 ;
31114 PyObject * obj0 = 0 ;
31115 PyObject * obj1 = 0 ;
31116 char *kwnames[] = {
31117 (char *) "self",(char *) "string", NULL
31118 };
31119
31120 arg3 = &temp3; res3 = SWIG_NEWOBJ;
31121 arg4 = &temp4; res4 = SWIG_NEWOBJ;
31122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
31123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31124 if (SWIG_arg_fail(1)) SWIG_fail;
31125 {
31126 arg2 = wxString_in_helper(obj1);
31127 if (arg2 == NULL) SWIG_fail;
31128 temp2 = true;
31129 }
31130 {
31131 PyThreadState* __tstate = wxPyBeginAllowThreads();
31132 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
31133
31134 wxPyEndAllowThreads(__tstate);
31135 if (PyErr_Occurred()) SWIG_fail;
31136 }
31137 Py_INCREF(Py_None); resultobj = Py_None;
31138 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31139 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31140 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
31141 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
31142 {
31143 if (temp2)
31144 delete arg2;
31145 }
31146 return resultobj;
31147 fail:
31148 {
31149 if (temp2)
31150 delete arg2;
31151 }
31152 return NULL;
31153 }
31154
31155
31156 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
31157 PyObject *resultobj = NULL;
31158 wxWindow *arg1 = (wxWindow *) 0 ;
31159 wxString *arg2 = 0 ;
31160 int *arg3 = (int *) 0 ;
31161 int *arg4 = (int *) 0 ;
31162 int *arg5 = (int *) 0 ;
31163 int *arg6 = (int *) 0 ;
31164 wxFont *arg7 = (wxFont *) NULL ;
31165 bool temp2 = false ;
31166 int temp3 ;
31167 int res3 = 0 ;
31168 int temp4 ;
31169 int res4 = 0 ;
31170 int temp5 ;
31171 int res5 = 0 ;
31172 int temp6 ;
31173 int res6 = 0 ;
31174 PyObject * obj0 = 0 ;
31175 PyObject * obj1 = 0 ;
31176 PyObject * obj2 = 0 ;
31177 char *kwnames[] = {
31178 (char *) "self",(char *) "string",(char *) "font", NULL
31179 };
31180
31181 arg3 = &temp3; res3 = SWIG_NEWOBJ;
31182 arg4 = &temp4; res4 = SWIG_NEWOBJ;
31183 arg5 = &temp5; res5 = SWIG_NEWOBJ;
31184 arg6 = &temp6; res6 = SWIG_NEWOBJ;
31185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
31186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31187 if (SWIG_arg_fail(1)) SWIG_fail;
31188 {
31189 arg2 = wxString_in_helper(obj1);
31190 if (arg2 == NULL) SWIG_fail;
31191 temp2 = true;
31192 }
31193 if (obj2) {
31194 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
31195 if (SWIG_arg_fail(7)) SWIG_fail;
31196 }
31197 {
31198 PyThreadState* __tstate = wxPyBeginAllowThreads();
31199 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
31200
31201 wxPyEndAllowThreads(__tstate);
31202 if (PyErr_Occurred()) SWIG_fail;
31203 }
31204 Py_INCREF(Py_None); resultobj = Py_None;
31205 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31206 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31207 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
31208 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
31209 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
31210 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
31211 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
31212 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
31213 {
31214 if (temp2)
31215 delete arg2;
31216 }
31217 return resultobj;
31218 fail:
31219 {
31220 if (temp2)
31221 delete arg2;
31222 }
31223 return NULL;
31224 }
31225
31226
31227 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
31228 PyObject *resultobj = NULL;
31229 wxWindow *arg1 = (wxWindow *) 0 ;
31230 int *arg2 = (int *) 0 ;
31231 int *arg3 = (int *) 0 ;
31232 int temp2 ;
31233 int res2 = 0 ;
31234 int temp3 ;
31235 int res3 = 0 ;
31236 PyObject * obj0 = 0 ;
31237 PyObject * obj1 = 0 ;
31238 PyObject * obj2 = 0 ;
31239 char *kwnames[] = {
31240 (char *) "self",(char *) "x",(char *) "y", NULL
31241 };
31242
31243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31245 if (SWIG_arg_fail(1)) SWIG_fail;
31246 {
31247 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31248 temp2 = SWIG_As_int(obj1);
31249 if (SWIG_arg_fail(2)) SWIG_fail;
31250 arg2 = &temp2;
31251 res2 = SWIG_NEWOBJ;
31252 }
31253 }
31254 {
31255 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31256 temp3 = SWIG_As_int(obj2);
31257 if (SWIG_arg_fail(3)) SWIG_fail;
31258 arg3 = &temp3;
31259 res3 = SWIG_NEWOBJ;
31260 }
31261 }
31262 {
31263 PyThreadState* __tstate = wxPyBeginAllowThreads();
31264 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
31265
31266 wxPyEndAllowThreads(__tstate);
31267 if (PyErr_Occurred()) SWIG_fail;
31268 }
31269 Py_INCREF(Py_None); resultobj = Py_None;
31270 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31271 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31272 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31273 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31274 return resultobj;
31275 fail:
31276 return NULL;
31277 }
31278
31279
31280 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
31281 PyObject *resultobj = NULL;
31282 wxWindow *arg1 = (wxWindow *) 0 ;
31283 int *arg2 = (int *) 0 ;
31284 int *arg3 = (int *) 0 ;
31285 int temp2 ;
31286 int res2 = 0 ;
31287 int temp3 ;
31288 int res3 = 0 ;
31289 PyObject * obj0 = 0 ;
31290 PyObject * obj1 = 0 ;
31291 PyObject * obj2 = 0 ;
31292 char *kwnames[] = {
31293 (char *) "self",(char *) "x",(char *) "y", NULL
31294 };
31295
31296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31298 if (SWIG_arg_fail(1)) SWIG_fail;
31299 {
31300 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31301 temp2 = SWIG_As_int(obj1);
31302 if (SWIG_arg_fail(2)) SWIG_fail;
31303 arg2 = &temp2;
31304 res2 = SWIG_NEWOBJ;
31305 }
31306 }
31307 {
31308 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31309 temp3 = SWIG_As_int(obj2);
31310 if (SWIG_arg_fail(3)) SWIG_fail;
31311 arg3 = &temp3;
31312 res3 = SWIG_NEWOBJ;
31313 }
31314 }
31315 {
31316 PyThreadState* __tstate = wxPyBeginAllowThreads();
31317 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
31318
31319 wxPyEndAllowThreads(__tstate);
31320 if (PyErr_Occurred()) SWIG_fail;
31321 }
31322 Py_INCREF(Py_None); resultobj = Py_None;
31323 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31324 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31325 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31326 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31327 return resultobj;
31328 fail:
31329 return NULL;
31330 }
31331
31332
31333 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
31334 PyObject *resultobj = NULL;
31335 wxWindow *arg1 = (wxWindow *) 0 ;
31336 wxPoint *arg2 = 0 ;
31337 wxPoint result;
31338 wxPoint temp2 ;
31339 PyObject * obj0 = 0 ;
31340 PyObject * obj1 = 0 ;
31341 char *kwnames[] = {
31342 (char *) "self",(char *) "pt", NULL
31343 };
31344
31345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
31346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31347 if (SWIG_arg_fail(1)) SWIG_fail;
31348 {
31349 arg2 = &temp2;
31350 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31351 }
31352 {
31353 PyThreadState* __tstate = wxPyBeginAllowThreads();
31354 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
31355
31356 wxPyEndAllowThreads(__tstate);
31357 if (PyErr_Occurred()) SWIG_fail;
31358 }
31359 {
31360 wxPoint * resultptr;
31361 resultptr = new wxPoint(static_cast<wxPoint & >(result));
31362 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31363 }
31364 return resultobj;
31365 fail:
31366 return NULL;
31367 }
31368
31369
31370 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
31371 PyObject *resultobj = NULL;
31372 wxWindow *arg1 = (wxWindow *) 0 ;
31373 wxPoint *arg2 = 0 ;
31374 wxPoint result;
31375 wxPoint temp2 ;
31376 PyObject * obj0 = 0 ;
31377 PyObject * obj1 = 0 ;
31378 char *kwnames[] = {
31379 (char *) "self",(char *) "pt", NULL
31380 };
31381
31382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
31383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31384 if (SWIG_arg_fail(1)) SWIG_fail;
31385 {
31386 arg2 = &temp2;
31387 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31388 }
31389 {
31390 PyThreadState* __tstate = wxPyBeginAllowThreads();
31391 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
31392
31393 wxPyEndAllowThreads(__tstate);
31394 if (PyErr_Occurred()) SWIG_fail;
31395 }
31396 {
31397 wxPoint * resultptr;
31398 resultptr = new wxPoint(static_cast<wxPoint & >(result));
31399 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31400 }
31401 return resultobj;
31402 fail:
31403 return NULL;
31404 }
31405
31406
31407 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
31408 PyObject *resultobj = NULL;
31409 wxWindow *arg1 = (wxWindow *) 0 ;
31410 int arg2 ;
31411 int arg3 ;
31412 wxHitTest result;
31413 PyObject * obj0 = 0 ;
31414 PyObject * obj1 = 0 ;
31415 PyObject * obj2 = 0 ;
31416 char *kwnames[] = {
31417 (char *) "self",(char *) "x",(char *) "y", NULL
31418 };
31419
31420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31422 if (SWIG_arg_fail(1)) SWIG_fail;
31423 {
31424 arg2 = static_cast<int >(SWIG_As_int(obj1));
31425 if (SWIG_arg_fail(2)) SWIG_fail;
31426 }
31427 {
31428 arg3 = static_cast<int >(SWIG_As_int(obj2));
31429 if (SWIG_arg_fail(3)) SWIG_fail;
31430 }
31431 {
31432 PyThreadState* __tstate = wxPyBeginAllowThreads();
31433 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
31434
31435 wxPyEndAllowThreads(__tstate);
31436 if (PyErr_Occurred()) SWIG_fail;
31437 }
31438 resultobj = SWIG_From_int((result));
31439 return resultobj;
31440 fail:
31441 return NULL;
31442 }
31443
31444
31445 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
31446 PyObject *resultobj = NULL;
31447 wxWindow *arg1 = (wxWindow *) 0 ;
31448 wxPoint *arg2 = 0 ;
31449 wxHitTest result;
31450 wxPoint temp2 ;
31451 PyObject * obj0 = 0 ;
31452 PyObject * obj1 = 0 ;
31453 char *kwnames[] = {
31454 (char *) "self",(char *) "pt", NULL
31455 };
31456
31457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
31458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31459 if (SWIG_arg_fail(1)) SWIG_fail;
31460 {
31461 arg2 = &temp2;
31462 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31463 }
31464 {
31465 PyThreadState* __tstate = wxPyBeginAllowThreads();
31466 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
31467
31468 wxPyEndAllowThreads(__tstate);
31469 if (PyErr_Occurred()) SWIG_fail;
31470 }
31471 resultobj = SWIG_From_int((result));
31472 return resultobj;
31473 fail:
31474 return NULL;
31475 }
31476
31477
31478 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
31479 PyObject *resultobj = NULL;
31480 wxWindow *arg1 = (wxWindow *) 0 ;
31481 long arg2 ;
31482 wxBorder result;
31483 PyObject * obj0 = 0 ;
31484 PyObject * obj1 = 0 ;
31485
31486 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
31487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31488 if (SWIG_arg_fail(1)) SWIG_fail;
31489 {
31490 arg2 = static_cast<long >(SWIG_As_long(obj1));
31491 if (SWIG_arg_fail(2)) SWIG_fail;
31492 }
31493 {
31494 PyThreadState* __tstate = wxPyBeginAllowThreads();
31495 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
31496
31497 wxPyEndAllowThreads(__tstate);
31498 if (PyErr_Occurred()) SWIG_fail;
31499 }
31500 resultobj = SWIG_From_int((result));
31501 return resultobj;
31502 fail:
31503 return NULL;
31504 }
31505
31506
31507 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
31508 PyObject *resultobj = NULL;
31509 wxWindow *arg1 = (wxWindow *) 0 ;
31510 wxBorder result;
31511 PyObject * obj0 = 0 ;
31512
31513 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
31514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31515 if (SWIG_arg_fail(1)) SWIG_fail;
31516 {
31517 PyThreadState* __tstate = wxPyBeginAllowThreads();
31518 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
31519
31520 wxPyEndAllowThreads(__tstate);
31521 if (PyErr_Occurred()) SWIG_fail;
31522 }
31523 resultobj = SWIG_From_int((result));
31524 return resultobj;
31525 fail:
31526 return NULL;
31527 }
31528
31529
31530 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
31531 int argc;
31532 PyObject *argv[3];
31533 int ii;
31534
31535 argc = PyObject_Length(args);
31536 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
31537 argv[ii] = PyTuple_GetItem(args,ii);
31538 }
31539 if (argc == 1) {
31540 int _v;
31541 {
31542 void *ptr;
31543 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31544 _v = 0;
31545 PyErr_Clear();
31546 } else {
31547 _v = 1;
31548 }
31549 }
31550 if (_v) {
31551 return _wrap_Window_GetBorder__SWIG_1(self,args);
31552 }
31553 }
31554 if (argc == 2) {
31555 int _v;
31556 {
31557 void *ptr;
31558 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31559 _v = 0;
31560 PyErr_Clear();
31561 } else {
31562 _v = 1;
31563 }
31564 }
31565 if (_v) {
31566 _v = SWIG_Check_long(argv[1]);
31567 if (_v) {
31568 return _wrap_Window_GetBorder__SWIG_0(self,args);
31569 }
31570 }
31571 }
31572
31573 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
31574 return NULL;
31575 }
31576
31577
31578 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
31579 PyObject *resultobj = NULL;
31580 wxWindow *arg1 = (wxWindow *) 0 ;
31581 long arg2 = (long) wxUPDATE_UI_NONE ;
31582 PyObject * obj0 = 0 ;
31583 PyObject * obj1 = 0 ;
31584 char *kwnames[] = {
31585 (char *) "self",(char *) "flags", NULL
31586 };
31587
31588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
31589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31590 if (SWIG_arg_fail(1)) SWIG_fail;
31591 if (obj1) {
31592 {
31593 arg2 = static_cast<long >(SWIG_As_long(obj1));
31594 if (SWIG_arg_fail(2)) SWIG_fail;
31595 }
31596 }
31597 {
31598 PyThreadState* __tstate = wxPyBeginAllowThreads();
31599 (arg1)->UpdateWindowUI(arg2);
31600
31601 wxPyEndAllowThreads(__tstate);
31602 if (PyErr_Occurred()) SWIG_fail;
31603 }
31604 Py_INCREF(Py_None); resultobj = Py_None;
31605 return resultobj;
31606 fail:
31607 return NULL;
31608 }
31609
31610
31611 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
31612 PyObject *resultobj = NULL;
31613 wxWindow *arg1 = (wxWindow *) 0 ;
31614 wxMenu *arg2 = (wxMenu *) 0 ;
31615 int arg3 = (int) -1 ;
31616 int arg4 = (int) -1 ;
31617 bool result;
31618 PyObject * obj0 = 0 ;
31619 PyObject * obj1 = 0 ;
31620 PyObject * obj2 = 0 ;
31621 PyObject * obj3 = 0 ;
31622 char *kwnames[] = {
31623 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
31624 };
31625
31626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31628 if (SWIG_arg_fail(1)) SWIG_fail;
31629 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31630 if (SWIG_arg_fail(2)) SWIG_fail;
31631 if (obj2) {
31632 {
31633 arg3 = static_cast<int >(SWIG_As_int(obj2));
31634 if (SWIG_arg_fail(3)) SWIG_fail;
31635 }
31636 }
31637 if (obj3) {
31638 {
31639 arg4 = static_cast<int >(SWIG_As_int(obj3));
31640 if (SWIG_arg_fail(4)) SWIG_fail;
31641 }
31642 }
31643 {
31644 PyThreadState* __tstate = wxPyBeginAllowThreads();
31645 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
31646
31647 wxPyEndAllowThreads(__tstate);
31648 if (PyErr_Occurred()) SWIG_fail;
31649 }
31650 {
31651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31652 }
31653 return resultobj;
31654 fail:
31655 return NULL;
31656 }
31657
31658
31659 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
31660 PyObject *resultobj = NULL;
31661 wxWindow *arg1 = (wxWindow *) 0 ;
31662 wxMenu *arg2 = (wxMenu *) 0 ;
31663 wxPoint const &arg3_defvalue = wxDefaultPosition ;
31664 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
31665 bool result;
31666 wxPoint temp3 ;
31667 PyObject * obj0 = 0 ;
31668 PyObject * obj1 = 0 ;
31669 PyObject * obj2 = 0 ;
31670 char *kwnames[] = {
31671 (char *) "self",(char *) "menu",(char *) "pos", NULL
31672 };
31673
31674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
31675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31676 if (SWIG_arg_fail(1)) SWIG_fail;
31677 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31678 if (SWIG_arg_fail(2)) SWIG_fail;
31679 if (obj2) {
31680 {
31681 arg3 = &temp3;
31682 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
31683 }
31684 }
31685 {
31686 PyThreadState* __tstate = wxPyBeginAllowThreads();
31687 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
31688
31689 wxPyEndAllowThreads(__tstate);
31690 if (PyErr_Occurred()) SWIG_fail;
31691 }
31692 {
31693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31694 }
31695 return resultobj;
31696 fail:
31697 return NULL;
31698 }
31699
31700
31701 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31702 PyObject *resultobj = NULL;
31703 wxWindow *arg1 = (wxWindow *) 0 ;
31704 long result;
31705 PyObject * obj0 = 0 ;
31706 char *kwnames[] = {
31707 (char *) "self", NULL
31708 };
31709
31710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
31711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31712 if (SWIG_arg_fail(1)) SWIG_fail;
31713 {
31714 PyThreadState* __tstate = wxPyBeginAllowThreads();
31715 result = (long)wxWindow_GetHandle(arg1);
31716
31717 wxPyEndAllowThreads(__tstate);
31718 if (PyErr_Occurred()) SWIG_fail;
31719 }
31720 {
31721 resultobj = SWIG_From_long(static_cast<long >(result));
31722 }
31723 return resultobj;
31724 fail:
31725 return NULL;
31726 }
31727
31728
31729 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31730 PyObject *resultobj = NULL;
31731 wxWindow *arg1 = (wxWindow *) 0 ;
31732 long arg2 ;
31733 PyObject * obj0 = 0 ;
31734 PyObject * obj1 = 0 ;
31735 char *kwnames[] = {
31736 (char *) "self",(char *) "handle", NULL
31737 };
31738
31739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
31740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31741 if (SWIG_arg_fail(1)) SWIG_fail;
31742 {
31743 arg2 = static_cast<long >(SWIG_As_long(obj1));
31744 if (SWIG_arg_fail(2)) SWIG_fail;
31745 }
31746 {
31747 PyThreadState* __tstate = wxPyBeginAllowThreads();
31748 wxWindow_AssociateHandle(arg1,arg2);
31749
31750 wxPyEndAllowThreads(__tstate);
31751 if (PyErr_Occurred()) SWIG_fail;
31752 }
31753 Py_INCREF(Py_None); resultobj = Py_None;
31754 return resultobj;
31755 fail:
31756 return NULL;
31757 }
31758
31759
31760 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31761 PyObject *resultobj = NULL;
31762 wxWindow *arg1 = (wxWindow *) 0 ;
31763 PyObject * obj0 = 0 ;
31764 char *kwnames[] = {
31765 (char *) "self", NULL
31766 };
31767
31768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
31769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31770 if (SWIG_arg_fail(1)) SWIG_fail;
31771 {
31772 PyThreadState* __tstate = wxPyBeginAllowThreads();
31773 (arg1)->DissociateHandle();
31774
31775 wxPyEndAllowThreads(__tstate);
31776 if (PyErr_Occurred()) SWIG_fail;
31777 }
31778 Py_INCREF(Py_None); resultobj = Py_None;
31779 return resultobj;
31780 fail:
31781 return NULL;
31782 }
31783
31784
31785 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31786 PyObject *resultobj = NULL;
31787 wxWindow *arg1 = (wxWindow *) 0 ;
31788 int arg2 ;
31789 bool result;
31790 PyObject * obj0 = 0 ;
31791 PyObject * obj1 = 0 ;
31792 char *kwnames[] = {
31793 (char *) "self",(char *) "orient", NULL
31794 };
31795
31796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31798 if (SWIG_arg_fail(1)) SWIG_fail;
31799 {
31800 arg2 = static_cast<int >(SWIG_As_int(obj1));
31801 if (SWIG_arg_fail(2)) SWIG_fail;
31802 }
31803 {
31804 PyThreadState* __tstate = wxPyBeginAllowThreads();
31805 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31806
31807 wxPyEndAllowThreads(__tstate);
31808 if (PyErr_Occurred()) SWIG_fail;
31809 }
31810 {
31811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31812 }
31813 return resultobj;
31814 fail:
31815 return NULL;
31816 }
31817
31818
31819 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31820 PyObject *resultobj = NULL;
31821 wxWindow *arg1 = (wxWindow *) 0 ;
31822 int arg2 ;
31823 int arg3 ;
31824 int arg4 ;
31825 int arg5 ;
31826 bool arg6 = (bool) true ;
31827 PyObject * obj0 = 0 ;
31828 PyObject * obj1 = 0 ;
31829 PyObject * obj2 = 0 ;
31830 PyObject * obj3 = 0 ;
31831 PyObject * obj4 = 0 ;
31832 PyObject * obj5 = 0 ;
31833 char *kwnames[] = {
31834 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31835 };
31836
31837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31839 if (SWIG_arg_fail(1)) SWIG_fail;
31840 {
31841 arg2 = static_cast<int >(SWIG_As_int(obj1));
31842 if (SWIG_arg_fail(2)) SWIG_fail;
31843 }
31844 {
31845 arg3 = static_cast<int >(SWIG_As_int(obj2));
31846 if (SWIG_arg_fail(3)) SWIG_fail;
31847 }
31848 {
31849 arg4 = static_cast<int >(SWIG_As_int(obj3));
31850 if (SWIG_arg_fail(4)) SWIG_fail;
31851 }
31852 {
31853 arg5 = static_cast<int >(SWIG_As_int(obj4));
31854 if (SWIG_arg_fail(5)) SWIG_fail;
31855 }
31856 if (obj5) {
31857 {
31858 arg6 = static_cast<bool >(SWIG_As_bool(obj5));
31859 if (SWIG_arg_fail(6)) SWIG_fail;
31860 }
31861 }
31862 {
31863 PyThreadState* __tstate = wxPyBeginAllowThreads();
31864 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31865
31866 wxPyEndAllowThreads(__tstate);
31867 if (PyErr_Occurred()) SWIG_fail;
31868 }
31869 Py_INCREF(Py_None); resultobj = Py_None;
31870 return resultobj;
31871 fail:
31872 return NULL;
31873 }
31874
31875
31876 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31877 PyObject *resultobj = NULL;
31878 wxWindow *arg1 = (wxWindow *) 0 ;
31879 int arg2 ;
31880 int arg3 ;
31881 bool arg4 = (bool) true ;
31882 PyObject * obj0 = 0 ;
31883 PyObject * obj1 = 0 ;
31884 PyObject * obj2 = 0 ;
31885 PyObject * obj3 = 0 ;
31886 char *kwnames[] = {
31887 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31888 };
31889
31890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31892 if (SWIG_arg_fail(1)) SWIG_fail;
31893 {
31894 arg2 = static_cast<int >(SWIG_As_int(obj1));
31895 if (SWIG_arg_fail(2)) SWIG_fail;
31896 }
31897 {
31898 arg3 = static_cast<int >(SWIG_As_int(obj2));
31899 if (SWIG_arg_fail(3)) SWIG_fail;
31900 }
31901 if (obj3) {
31902 {
31903 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
31904 if (SWIG_arg_fail(4)) SWIG_fail;
31905 }
31906 }
31907 {
31908 PyThreadState* __tstate = wxPyBeginAllowThreads();
31909 (arg1)->SetScrollPos(arg2,arg3,arg4);
31910
31911 wxPyEndAllowThreads(__tstate);
31912 if (PyErr_Occurred()) SWIG_fail;
31913 }
31914 Py_INCREF(Py_None); resultobj = Py_None;
31915 return resultobj;
31916 fail:
31917 return NULL;
31918 }
31919
31920
31921 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31922 PyObject *resultobj = NULL;
31923 wxWindow *arg1 = (wxWindow *) 0 ;
31924 int arg2 ;
31925 int result;
31926 PyObject * obj0 = 0 ;
31927 PyObject * obj1 = 0 ;
31928 char *kwnames[] = {
31929 (char *) "self",(char *) "orientation", NULL
31930 };
31931
31932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31934 if (SWIG_arg_fail(1)) SWIG_fail;
31935 {
31936 arg2 = static_cast<int >(SWIG_As_int(obj1));
31937 if (SWIG_arg_fail(2)) SWIG_fail;
31938 }
31939 {
31940 PyThreadState* __tstate = wxPyBeginAllowThreads();
31941 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31942
31943 wxPyEndAllowThreads(__tstate);
31944 if (PyErr_Occurred()) SWIG_fail;
31945 }
31946 {
31947 resultobj = SWIG_From_int(static_cast<int >(result));
31948 }
31949 return resultobj;
31950 fail:
31951 return NULL;
31952 }
31953
31954
31955 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31956 PyObject *resultobj = NULL;
31957 wxWindow *arg1 = (wxWindow *) 0 ;
31958 int arg2 ;
31959 int result;
31960 PyObject * obj0 = 0 ;
31961 PyObject * obj1 = 0 ;
31962 char *kwnames[] = {
31963 (char *) "self",(char *) "orientation", NULL
31964 };
31965
31966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31968 if (SWIG_arg_fail(1)) SWIG_fail;
31969 {
31970 arg2 = static_cast<int >(SWIG_As_int(obj1));
31971 if (SWIG_arg_fail(2)) SWIG_fail;
31972 }
31973 {
31974 PyThreadState* __tstate = wxPyBeginAllowThreads();
31975 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31976
31977 wxPyEndAllowThreads(__tstate);
31978 if (PyErr_Occurred()) SWIG_fail;
31979 }
31980 {
31981 resultobj = SWIG_From_int(static_cast<int >(result));
31982 }
31983 return resultobj;
31984 fail:
31985 return NULL;
31986 }
31987
31988
31989 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31990 PyObject *resultobj = NULL;
31991 wxWindow *arg1 = (wxWindow *) 0 ;
31992 int arg2 ;
31993 int result;
31994 PyObject * obj0 = 0 ;
31995 PyObject * obj1 = 0 ;
31996 char *kwnames[] = {
31997 (char *) "self",(char *) "orientation", NULL
31998 };
31999
32000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
32001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32002 if (SWIG_arg_fail(1)) SWIG_fail;
32003 {
32004 arg2 = static_cast<int >(SWIG_As_int(obj1));
32005 if (SWIG_arg_fail(2)) SWIG_fail;
32006 }
32007 {
32008 PyThreadState* __tstate = wxPyBeginAllowThreads();
32009 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
32010
32011 wxPyEndAllowThreads(__tstate);
32012 if (PyErr_Occurred()) SWIG_fail;
32013 }
32014 {
32015 resultobj = SWIG_From_int(static_cast<int >(result));
32016 }
32017 return resultobj;
32018 fail:
32019 return NULL;
32020 }
32021
32022
32023 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32024 PyObject *resultobj = NULL;
32025 wxWindow *arg1 = (wxWindow *) 0 ;
32026 int arg2 ;
32027 int arg3 ;
32028 wxRect *arg4 = (wxRect *) NULL ;
32029 PyObject * obj0 = 0 ;
32030 PyObject * obj1 = 0 ;
32031 PyObject * obj2 = 0 ;
32032 PyObject * obj3 = 0 ;
32033 char *kwnames[] = {
32034 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
32035 };
32036
32037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32039 if (SWIG_arg_fail(1)) SWIG_fail;
32040 {
32041 arg2 = static_cast<int >(SWIG_As_int(obj1));
32042 if (SWIG_arg_fail(2)) SWIG_fail;
32043 }
32044 {
32045 arg3 = static_cast<int >(SWIG_As_int(obj2));
32046 if (SWIG_arg_fail(3)) SWIG_fail;
32047 }
32048 if (obj3) {
32049 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
32050 if (SWIG_arg_fail(4)) SWIG_fail;
32051 }
32052 {
32053 PyThreadState* __tstate = wxPyBeginAllowThreads();
32054 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
32055
32056 wxPyEndAllowThreads(__tstate);
32057 if (PyErr_Occurred()) SWIG_fail;
32058 }
32059 Py_INCREF(Py_None); resultobj = Py_None;
32060 return resultobj;
32061 fail:
32062 return NULL;
32063 }
32064
32065
32066 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
32067 PyObject *resultobj = NULL;
32068 wxWindow *arg1 = (wxWindow *) 0 ;
32069 int arg2 ;
32070 bool result;
32071 PyObject * obj0 = 0 ;
32072 PyObject * obj1 = 0 ;
32073 char *kwnames[] = {
32074 (char *) "self",(char *) "lines", NULL
32075 };
32076
32077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
32078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32079 if (SWIG_arg_fail(1)) SWIG_fail;
32080 {
32081 arg2 = static_cast<int >(SWIG_As_int(obj1));
32082 if (SWIG_arg_fail(2)) SWIG_fail;
32083 }
32084 {
32085 PyThreadState* __tstate = wxPyBeginAllowThreads();
32086 result = (bool)(arg1)->ScrollLines(arg2);
32087
32088 wxPyEndAllowThreads(__tstate);
32089 if (PyErr_Occurred()) SWIG_fail;
32090 }
32091 {
32092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32093 }
32094 return resultobj;
32095 fail:
32096 return NULL;
32097 }
32098
32099
32100 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
32101 PyObject *resultobj = NULL;
32102 wxWindow *arg1 = (wxWindow *) 0 ;
32103 int arg2 ;
32104 bool result;
32105 PyObject * obj0 = 0 ;
32106 PyObject * obj1 = 0 ;
32107 char *kwnames[] = {
32108 (char *) "self",(char *) "pages", NULL
32109 };
32110
32111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
32112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32113 if (SWIG_arg_fail(1)) SWIG_fail;
32114 {
32115 arg2 = static_cast<int >(SWIG_As_int(obj1));
32116 if (SWIG_arg_fail(2)) SWIG_fail;
32117 }
32118 {
32119 PyThreadState* __tstate = wxPyBeginAllowThreads();
32120 result = (bool)(arg1)->ScrollPages(arg2);
32121
32122 wxPyEndAllowThreads(__tstate);
32123 if (PyErr_Occurred()) SWIG_fail;
32124 }
32125 {
32126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32127 }
32128 return resultobj;
32129 fail:
32130 return NULL;
32131 }
32132
32133
32134 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
32135 PyObject *resultobj = NULL;
32136 wxWindow *arg1 = (wxWindow *) 0 ;
32137 bool result;
32138 PyObject * obj0 = 0 ;
32139 char *kwnames[] = {
32140 (char *) "self", NULL
32141 };
32142
32143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
32144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32145 if (SWIG_arg_fail(1)) SWIG_fail;
32146 {
32147 PyThreadState* __tstate = wxPyBeginAllowThreads();
32148 result = (bool)(arg1)->LineUp();
32149
32150 wxPyEndAllowThreads(__tstate);
32151 if (PyErr_Occurred()) SWIG_fail;
32152 }
32153 {
32154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32155 }
32156 return resultobj;
32157 fail:
32158 return NULL;
32159 }
32160
32161
32162 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
32163 PyObject *resultobj = NULL;
32164 wxWindow *arg1 = (wxWindow *) 0 ;
32165 bool result;
32166 PyObject * obj0 = 0 ;
32167 char *kwnames[] = {
32168 (char *) "self", NULL
32169 };
32170
32171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
32172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32173 if (SWIG_arg_fail(1)) SWIG_fail;
32174 {
32175 PyThreadState* __tstate = wxPyBeginAllowThreads();
32176 result = (bool)(arg1)->LineDown();
32177
32178 wxPyEndAllowThreads(__tstate);
32179 if (PyErr_Occurred()) SWIG_fail;
32180 }
32181 {
32182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32183 }
32184 return resultobj;
32185 fail:
32186 return NULL;
32187 }
32188
32189
32190 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
32191 PyObject *resultobj = NULL;
32192 wxWindow *arg1 = (wxWindow *) 0 ;
32193 bool result;
32194 PyObject * obj0 = 0 ;
32195 char *kwnames[] = {
32196 (char *) "self", NULL
32197 };
32198
32199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
32200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32201 if (SWIG_arg_fail(1)) SWIG_fail;
32202 {
32203 PyThreadState* __tstate = wxPyBeginAllowThreads();
32204 result = (bool)(arg1)->PageUp();
32205
32206 wxPyEndAllowThreads(__tstate);
32207 if (PyErr_Occurred()) SWIG_fail;
32208 }
32209 {
32210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32211 }
32212 return resultobj;
32213 fail:
32214 return NULL;
32215 }
32216
32217
32218 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
32219 PyObject *resultobj = NULL;
32220 wxWindow *arg1 = (wxWindow *) 0 ;
32221 bool result;
32222 PyObject * obj0 = 0 ;
32223 char *kwnames[] = {
32224 (char *) "self", NULL
32225 };
32226
32227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
32228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32229 if (SWIG_arg_fail(1)) SWIG_fail;
32230 {
32231 PyThreadState* __tstate = wxPyBeginAllowThreads();
32232 result = (bool)(arg1)->PageDown();
32233
32234 wxPyEndAllowThreads(__tstate);
32235 if (PyErr_Occurred()) SWIG_fail;
32236 }
32237 {
32238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32239 }
32240 return resultobj;
32241 fail:
32242 return NULL;
32243 }
32244
32245
32246 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32247 PyObject *resultobj = NULL;
32248 wxWindow *arg1 = (wxWindow *) 0 ;
32249 wxString *arg2 = 0 ;
32250 bool temp2 = false ;
32251 PyObject * obj0 = 0 ;
32252 PyObject * obj1 = 0 ;
32253 char *kwnames[] = {
32254 (char *) "self",(char *) "text", NULL
32255 };
32256
32257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
32258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32259 if (SWIG_arg_fail(1)) SWIG_fail;
32260 {
32261 arg2 = wxString_in_helper(obj1);
32262 if (arg2 == NULL) SWIG_fail;
32263 temp2 = true;
32264 }
32265 {
32266 PyThreadState* __tstate = wxPyBeginAllowThreads();
32267 (arg1)->SetHelpText((wxString const &)*arg2);
32268
32269 wxPyEndAllowThreads(__tstate);
32270 if (PyErr_Occurred()) SWIG_fail;
32271 }
32272 Py_INCREF(Py_None); resultobj = Py_None;
32273 {
32274 if (temp2)
32275 delete arg2;
32276 }
32277 return resultobj;
32278 fail:
32279 {
32280 if (temp2)
32281 delete arg2;
32282 }
32283 return NULL;
32284 }
32285
32286
32287 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
32288 PyObject *resultobj = NULL;
32289 wxWindow *arg1 = (wxWindow *) 0 ;
32290 wxString *arg2 = 0 ;
32291 bool temp2 = false ;
32292 PyObject * obj0 = 0 ;
32293 PyObject * obj1 = 0 ;
32294 char *kwnames[] = {
32295 (char *) "self",(char *) "text", NULL
32296 };
32297
32298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
32299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32300 if (SWIG_arg_fail(1)) SWIG_fail;
32301 {
32302 arg2 = wxString_in_helper(obj1);
32303 if (arg2 == NULL) SWIG_fail;
32304 temp2 = true;
32305 }
32306 {
32307 PyThreadState* __tstate = wxPyBeginAllowThreads();
32308 (arg1)->SetHelpTextForId((wxString const &)*arg2);
32309
32310 wxPyEndAllowThreads(__tstate);
32311 if (PyErr_Occurred()) SWIG_fail;
32312 }
32313 Py_INCREF(Py_None); resultobj = Py_None;
32314 {
32315 if (temp2)
32316 delete arg2;
32317 }
32318 return resultobj;
32319 fail:
32320 {
32321 if (temp2)
32322 delete arg2;
32323 }
32324 return NULL;
32325 }
32326
32327
32328 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32329 PyObject *resultobj = NULL;
32330 wxWindow *arg1 = (wxWindow *) 0 ;
32331 wxString result;
32332 PyObject * obj0 = 0 ;
32333 char *kwnames[] = {
32334 (char *) "self", NULL
32335 };
32336
32337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
32338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32339 if (SWIG_arg_fail(1)) SWIG_fail;
32340 {
32341 PyThreadState* __tstate = wxPyBeginAllowThreads();
32342 result = ((wxWindow const *)arg1)->GetHelpText();
32343
32344 wxPyEndAllowThreads(__tstate);
32345 if (PyErr_Occurred()) SWIG_fail;
32346 }
32347 {
32348 #if wxUSE_UNICODE
32349 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32350 #else
32351 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32352 #endif
32353 }
32354 return resultobj;
32355 fail:
32356 return NULL;
32357 }
32358
32359
32360 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
32361 PyObject *resultobj = NULL;
32362 wxWindow *arg1 = (wxWindow *) 0 ;
32363 wxString *arg2 = 0 ;
32364 bool temp2 = false ;
32365 PyObject * obj0 = 0 ;
32366 PyObject * obj1 = 0 ;
32367 char *kwnames[] = {
32368 (char *) "self",(char *) "tip", NULL
32369 };
32370
32371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
32372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32373 if (SWIG_arg_fail(1)) SWIG_fail;
32374 {
32375 arg2 = wxString_in_helper(obj1);
32376 if (arg2 == NULL) SWIG_fail;
32377 temp2 = true;
32378 }
32379 {
32380 PyThreadState* __tstate = wxPyBeginAllowThreads();
32381 (arg1)->SetToolTip((wxString const &)*arg2);
32382
32383 wxPyEndAllowThreads(__tstate);
32384 if (PyErr_Occurred()) SWIG_fail;
32385 }
32386 Py_INCREF(Py_None); resultobj = Py_None;
32387 {
32388 if (temp2)
32389 delete arg2;
32390 }
32391 return resultobj;
32392 fail:
32393 {
32394 if (temp2)
32395 delete arg2;
32396 }
32397 return NULL;
32398 }
32399
32400
32401 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32402 PyObject *resultobj = NULL;
32403 wxWindow *arg1 = (wxWindow *) 0 ;
32404 wxToolTip *arg2 = (wxToolTip *) 0 ;
32405 PyObject * obj0 = 0 ;
32406 PyObject * obj1 = 0 ;
32407 char *kwnames[] = {
32408 (char *) "self",(char *) "tip", NULL
32409 };
32410
32411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
32412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32413 if (SWIG_arg_fail(1)) SWIG_fail;
32414 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
32415 if (SWIG_arg_fail(2)) SWIG_fail;
32416 {
32417 PyThreadState* __tstate = wxPyBeginAllowThreads();
32418 (arg1)->SetToolTip(arg2);
32419
32420 wxPyEndAllowThreads(__tstate);
32421 if (PyErr_Occurred()) SWIG_fail;
32422 }
32423 Py_INCREF(Py_None); resultobj = Py_None;
32424 return resultobj;
32425 fail:
32426 return NULL;
32427 }
32428
32429
32430 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32431 PyObject *resultobj = NULL;
32432 wxWindow *arg1 = (wxWindow *) 0 ;
32433 wxToolTip *result;
32434 PyObject * obj0 = 0 ;
32435 char *kwnames[] = {
32436 (char *) "self", NULL
32437 };
32438
32439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
32440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32441 if (SWIG_arg_fail(1)) SWIG_fail;
32442 {
32443 PyThreadState* __tstate = wxPyBeginAllowThreads();
32444 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
32445
32446 wxPyEndAllowThreads(__tstate);
32447 if (PyErr_Occurred()) SWIG_fail;
32448 }
32449 {
32450 resultobj = wxPyMake_wxObject(result, 0);
32451 }
32452 return resultobj;
32453 fail:
32454 return NULL;
32455 }
32456
32457
32458 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32459 PyObject *resultobj = NULL;
32460 wxWindow *arg1 = (wxWindow *) 0 ;
32461 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
32462 PyObject * obj0 = 0 ;
32463 PyObject * obj1 = 0 ;
32464 char *kwnames[] = {
32465 (char *) "self",(char *) "dropTarget", NULL
32466 };
32467
32468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
32469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32470 if (SWIG_arg_fail(1)) SWIG_fail;
32471 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32472 if (SWIG_arg_fail(2)) SWIG_fail;
32473 {
32474 PyThreadState* __tstate = wxPyBeginAllowThreads();
32475 (arg1)->SetDropTarget(arg2);
32476
32477 wxPyEndAllowThreads(__tstate);
32478 if (PyErr_Occurred()) SWIG_fail;
32479 }
32480 Py_INCREF(Py_None); resultobj = Py_None;
32481 return resultobj;
32482 fail:
32483 return NULL;
32484 }
32485
32486
32487 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32488 PyObject *resultobj = NULL;
32489 wxWindow *arg1 = (wxWindow *) 0 ;
32490 wxPyDropTarget *result;
32491 PyObject * obj0 = 0 ;
32492 char *kwnames[] = {
32493 (char *) "self", NULL
32494 };
32495
32496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
32497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32498 if (SWIG_arg_fail(1)) SWIG_fail;
32499 {
32500 PyThreadState* __tstate = wxPyBeginAllowThreads();
32501 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
32502
32503 wxPyEndAllowThreads(__tstate);
32504 if (PyErr_Occurred()) SWIG_fail;
32505 }
32506 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
32507 return resultobj;
32508 fail:
32509 return NULL;
32510 }
32511
32512
32513 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
32514 PyObject *resultobj = NULL;
32515 wxWindow *arg1 = (wxWindow *) 0 ;
32516 bool arg2 ;
32517 PyObject * obj0 = 0 ;
32518 PyObject * obj1 = 0 ;
32519 char *kwnames[] = {
32520 (char *) "self",(char *) "accept", NULL
32521 };
32522
32523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
32524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32525 if (SWIG_arg_fail(1)) SWIG_fail;
32526 {
32527 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
32528 if (SWIG_arg_fail(2)) SWIG_fail;
32529 }
32530 {
32531 PyThreadState* __tstate = wxPyBeginAllowThreads();
32532 wxWindow_DragAcceptFiles(arg1,arg2);
32533
32534 wxPyEndAllowThreads(__tstate);
32535 if (PyErr_Occurred()) SWIG_fail;
32536 }
32537 Py_INCREF(Py_None); resultobj = Py_None;
32538 return resultobj;
32539 fail:
32540 return NULL;
32541 }
32542
32543
32544 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32545 PyObject *resultobj = NULL;
32546 wxWindow *arg1 = (wxWindow *) 0 ;
32547 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
32548 PyObject * obj0 = 0 ;
32549 PyObject * obj1 = 0 ;
32550 char *kwnames[] = {
32551 (char *) "self",(char *) "constraints", NULL
32552 };
32553
32554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
32555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32556 if (SWIG_arg_fail(1)) SWIG_fail;
32557 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
32558 if (SWIG_arg_fail(2)) SWIG_fail;
32559 {
32560 PyThreadState* __tstate = wxPyBeginAllowThreads();
32561 (arg1)->SetConstraints(arg2);
32562
32563 wxPyEndAllowThreads(__tstate);
32564 if (PyErr_Occurred()) SWIG_fail;
32565 }
32566 Py_INCREF(Py_None); resultobj = Py_None;
32567 return resultobj;
32568 fail:
32569 return NULL;
32570 }
32571
32572
32573 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32574 PyObject *resultobj = NULL;
32575 wxWindow *arg1 = (wxWindow *) 0 ;
32576 wxLayoutConstraints *result;
32577 PyObject * obj0 = 0 ;
32578 char *kwnames[] = {
32579 (char *) "self", NULL
32580 };
32581
32582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
32583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32584 if (SWIG_arg_fail(1)) SWIG_fail;
32585 {
32586 PyThreadState* __tstate = wxPyBeginAllowThreads();
32587 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
32588
32589 wxPyEndAllowThreads(__tstate);
32590 if (PyErr_Occurred()) SWIG_fail;
32591 }
32592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
32593 return resultobj;
32594 fail:
32595 return NULL;
32596 }
32597
32598
32599 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32600 PyObject *resultobj = NULL;
32601 wxWindow *arg1 = (wxWindow *) 0 ;
32602 bool arg2 ;
32603 PyObject * obj0 = 0 ;
32604 PyObject * obj1 = 0 ;
32605 char *kwnames[] = {
32606 (char *) "self",(char *) "autoLayout", NULL
32607 };
32608
32609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
32610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32611 if (SWIG_arg_fail(1)) SWIG_fail;
32612 {
32613 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
32614 if (SWIG_arg_fail(2)) SWIG_fail;
32615 }
32616 {
32617 PyThreadState* __tstate = wxPyBeginAllowThreads();
32618 (arg1)->SetAutoLayout(arg2);
32619
32620 wxPyEndAllowThreads(__tstate);
32621 if (PyErr_Occurred()) SWIG_fail;
32622 }
32623 Py_INCREF(Py_None); resultobj = Py_None;
32624 return resultobj;
32625 fail:
32626 return NULL;
32627 }
32628
32629
32630 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32631 PyObject *resultobj = NULL;
32632 wxWindow *arg1 = (wxWindow *) 0 ;
32633 bool result;
32634 PyObject * obj0 = 0 ;
32635 char *kwnames[] = {
32636 (char *) "self", NULL
32637 };
32638
32639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
32640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32641 if (SWIG_arg_fail(1)) SWIG_fail;
32642 {
32643 PyThreadState* __tstate = wxPyBeginAllowThreads();
32644 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
32645
32646 wxPyEndAllowThreads(__tstate);
32647 if (PyErr_Occurred()) SWIG_fail;
32648 }
32649 {
32650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32651 }
32652 return resultobj;
32653 fail:
32654 return NULL;
32655 }
32656
32657
32658 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
32659 PyObject *resultobj = NULL;
32660 wxWindow *arg1 = (wxWindow *) 0 ;
32661 bool result;
32662 PyObject * obj0 = 0 ;
32663 char *kwnames[] = {
32664 (char *) "self", NULL
32665 };
32666
32667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
32668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32669 if (SWIG_arg_fail(1)) SWIG_fail;
32670 {
32671 PyThreadState* __tstate = wxPyBeginAllowThreads();
32672 result = (bool)(arg1)->Layout();
32673
32674 wxPyEndAllowThreads(__tstate);
32675 if (PyErr_Occurred()) SWIG_fail;
32676 }
32677 {
32678 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32679 }
32680 return resultobj;
32681 fail:
32682 return NULL;
32683 }
32684
32685
32686 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32687 PyObject *resultobj = NULL;
32688 wxWindow *arg1 = (wxWindow *) 0 ;
32689 wxSizer *arg2 = (wxSizer *) 0 ;
32690 bool arg3 = (bool) true ;
32691 PyObject * obj0 = 0 ;
32692 PyObject * obj1 = 0 ;
32693 PyObject * obj2 = 0 ;
32694 char *kwnames[] = {
32695 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32696 };
32697
32698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
32699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32700 if (SWIG_arg_fail(1)) SWIG_fail;
32701 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32702 if (SWIG_arg_fail(2)) SWIG_fail;
32703 if (obj2) {
32704 {
32705 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
32706 if (SWIG_arg_fail(3)) SWIG_fail;
32707 }
32708 }
32709 {
32710 PyThreadState* __tstate = wxPyBeginAllowThreads();
32711 (arg1)->SetSizer(arg2,arg3);
32712
32713 wxPyEndAllowThreads(__tstate);
32714 if (PyErr_Occurred()) SWIG_fail;
32715 }
32716 Py_INCREF(Py_None); resultobj = Py_None;
32717 return resultobj;
32718 fail:
32719 return NULL;
32720 }
32721
32722
32723 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
32724 PyObject *resultobj = NULL;
32725 wxWindow *arg1 = (wxWindow *) 0 ;
32726 wxSizer *arg2 = (wxSizer *) 0 ;
32727 bool arg3 = (bool) true ;
32728 PyObject * obj0 = 0 ;
32729 PyObject * obj1 = 0 ;
32730 PyObject * obj2 = 0 ;
32731 char *kwnames[] = {
32732 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32733 };
32734
32735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
32736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32737 if (SWIG_arg_fail(1)) SWIG_fail;
32738 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32739 if (SWIG_arg_fail(2)) SWIG_fail;
32740 if (obj2) {
32741 {
32742 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
32743 if (SWIG_arg_fail(3)) SWIG_fail;
32744 }
32745 }
32746 {
32747 PyThreadState* __tstate = wxPyBeginAllowThreads();
32748 (arg1)->SetSizerAndFit(arg2,arg3);
32749
32750 wxPyEndAllowThreads(__tstate);
32751 if (PyErr_Occurred()) SWIG_fail;
32752 }
32753 Py_INCREF(Py_None); resultobj = Py_None;
32754 return resultobj;
32755 fail:
32756 return NULL;
32757 }
32758
32759
32760 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32761 PyObject *resultobj = NULL;
32762 wxWindow *arg1 = (wxWindow *) 0 ;
32763 wxSizer *result;
32764 PyObject * obj0 = 0 ;
32765 char *kwnames[] = {
32766 (char *) "self", NULL
32767 };
32768
32769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32771 if (SWIG_arg_fail(1)) SWIG_fail;
32772 {
32773 PyThreadState* __tstate = wxPyBeginAllowThreads();
32774 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32775
32776 wxPyEndAllowThreads(__tstate);
32777 if (PyErr_Occurred()) SWIG_fail;
32778 }
32779 {
32780 resultobj = wxPyMake_wxObject(result, 0);
32781 }
32782 return resultobj;
32783 fail:
32784 return NULL;
32785 }
32786
32787
32788 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32789 PyObject *resultobj = NULL;
32790 wxWindow *arg1 = (wxWindow *) 0 ;
32791 wxSizer *arg2 = (wxSizer *) 0 ;
32792 PyObject * obj0 = 0 ;
32793 PyObject * obj1 = 0 ;
32794 char *kwnames[] = {
32795 (char *) "self",(char *) "sizer", NULL
32796 };
32797
32798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32800 if (SWIG_arg_fail(1)) SWIG_fail;
32801 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32802 if (SWIG_arg_fail(2)) SWIG_fail;
32803 {
32804 PyThreadState* __tstate = wxPyBeginAllowThreads();
32805 (arg1)->SetContainingSizer(arg2);
32806
32807 wxPyEndAllowThreads(__tstate);
32808 if (PyErr_Occurred()) SWIG_fail;
32809 }
32810 Py_INCREF(Py_None); resultobj = Py_None;
32811 return resultobj;
32812 fail:
32813 return NULL;
32814 }
32815
32816
32817 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32818 PyObject *resultobj = NULL;
32819 wxWindow *arg1 = (wxWindow *) 0 ;
32820 wxSizer *result;
32821 PyObject * obj0 = 0 ;
32822 char *kwnames[] = {
32823 (char *) "self", NULL
32824 };
32825
32826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32828 if (SWIG_arg_fail(1)) SWIG_fail;
32829 {
32830 PyThreadState* __tstate = wxPyBeginAllowThreads();
32831 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32832
32833 wxPyEndAllowThreads(__tstate);
32834 if (PyErr_Occurred()) SWIG_fail;
32835 }
32836 {
32837 resultobj = wxPyMake_wxObject(result, 0);
32838 }
32839 return resultobj;
32840 fail:
32841 return NULL;
32842 }
32843
32844
32845 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32846 PyObject *resultobj = NULL;
32847 wxWindow *arg1 = (wxWindow *) 0 ;
32848 PyObject * obj0 = 0 ;
32849 char *kwnames[] = {
32850 (char *) "self", NULL
32851 };
32852
32853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32855 if (SWIG_arg_fail(1)) SWIG_fail;
32856 {
32857 PyThreadState* __tstate = wxPyBeginAllowThreads();
32858 (arg1)->InheritAttributes();
32859
32860 wxPyEndAllowThreads(__tstate);
32861 if (PyErr_Occurred()) SWIG_fail;
32862 }
32863 Py_INCREF(Py_None); resultobj = Py_None;
32864 return resultobj;
32865 fail:
32866 return NULL;
32867 }
32868
32869
32870 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32871 PyObject *resultobj = NULL;
32872 wxWindow *arg1 = (wxWindow *) 0 ;
32873 bool result;
32874 PyObject * obj0 = 0 ;
32875 char *kwnames[] = {
32876 (char *) "self", NULL
32877 };
32878
32879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32881 if (SWIG_arg_fail(1)) SWIG_fail;
32882 {
32883 PyThreadState* __tstate = wxPyBeginAllowThreads();
32884 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32885
32886 wxPyEndAllowThreads(__tstate);
32887 if (PyErr_Occurred()) SWIG_fail;
32888 }
32889 {
32890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32891 }
32892 return resultobj;
32893 fail:
32894 return NULL;
32895 }
32896
32897
32898 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32899 PyObject *obj;
32900 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32901 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32902 Py_INCREF(obj);
32903 return Py_BuildValue((char *)"");
32904 }
32905 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32906 PyObject *resultobj = NULL;
32907 long arg1 ;
32908 wxWindow *arg2 = (wxWindow *) NULL ;
32909 wxWindow *result;
32910 PyObject * obj0 = 0 ;
32911 PyObject * obj1 = 0 ;
32912 char *kwnames[] = {
32913 (char *) "id",(char *) "parent", NULL
32914 };
32915
32916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32917 {
32918 arg1 = static_cast<long >(SWIG_As_long(obj0));
32919 if (SWIG_arg_fail(1)) SWIG_fail;
32920 }
32921 if (obj1) {
32922 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32923 if (SWIG_arg_fail(2)) SWIG_fail;
32924 }
32925 {
32926 if (!wxPyCheckForApp()) SWIG_fail;
32927 PyThreadState* __tstate = wxPyBeginAllowThreads();
32928 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32929
32930 wxPyEndAllowThreads(__tstate);
32931 if (PyErr_Occurred()) SWIG_fail;
32932 }
32933 {
32934 resultobj = wxPyMake_wxObject(result, 0);
32935 }
32936 return resultobj;
32937 fail:
32938 return NULL;
32939 }
32940
32941
32942 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32943 PyObject *resultobj = NULL;
32944 wxString *arg1 = 0 ;
32945 wxWindow *arg2 = (wxWindow *) NULL ;
32946 wxWindow *result;
32947 bool temp1 = false ;
32948 PyObject * obj0 = 0 ;
32949 PyObject * obj1 = 0 ;
32950 char *kwnames[] = {
32951 (char *) "name",(char *) "parent", NULL
32952 };
32953
32954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32955 {
32956 arg1 = wxString_in_helper(obj0);
32957 if (arg1 == NULL) SWIG_fail;
32958 temp1 = true;
32959 }
32960 if (obj1) {
32961 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32962 if (SWIG_arg_fail(2)) SWIG_fail;
32963 }
32964 {
32965 if (!wxPyCheckForApp()) SWIG_fail;
32966 PyThreadState* __tstate = wxPyBeginAllowThreads();
32967 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32968
32969 wxPyEndAllowThreads(__tstate);
32970 if (PyErr_Occurred()) SWIG_fail;
32971 }
32972 {
32973 resultobj = wxPyMake_wxObject(result, 0);
32974 }
32975 {
32976 if (temp1)
32977 delete arg1;
32978 }
32979 return resultobj;
32980 fail:
32981 {
32982 if (temp1)
32983 delete arg1;
32984 }
32985 return NULL;
32986 }
32987
32988
32989 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32990 PyObject *resultobj = NULL;
32991 wxString *arg1 = 0 ;
32992 wxWindow *arg2 = (wxWindow *) NULL ;
32993 wxWindow *result;
32994 bool temp1 = false ;
32995 PyObject * obj0 = 0 ;
32996 PyObject * obj1 = 0 ;
32997 char *kwnames[] = {
32998 (char *) "label",(char *) "parent", NULL
32999 };
33000
33001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
33002 {
33003 arg1 = wxString_in_helper(obj0);
33004 if (arg1 == NULL) SWIG_fail;
33005 temp1 = true;
33006 }
33007 if (obj1) {
33008 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33009 if (SWIG_arg_fail(2)) SWIG_fail;
33010 }
33011 {
33012 if (!wxPyCheckForApp()) SWIG_fail;
33013 PyThreadState* __tstate = wxPyBeginAllowThreads();
33014 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
33015
33016 wxPyEndAllowThreads(__tstate);
33017 if (PyErr_Occurred()) SWIG_fail;
33018 }
33019 {
33020 resultobj = wxPyMake_wxObject(result, 0);
33021 }
33022 {
33023 if (temp1)
33024 delete arg1;
33025 }
33026 return resultobj;
33027 fail:
33028 {
33029 if (temp1)
33030 delete arg1;
33031 }
33032 return NULL;
33033 }
33034
33035
33036 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
33037 PyObject *resultobj = NULL;
33038 wxWindow *arg1 = (wxWindow *) 0 ;
33039 unsigned long arg2 ;
33040 wxWindow *result;
33041 PyObject * obj0 = 0 ;
33042 PyObject * obj1 = 0 ;
33043 char *kwnames[] = {
33044 (char *) "parent",(char *) "_hWnd", NULL
33045 };
33046
33047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
33048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33049 if (SWIG_arg_fail(1)) SWIG_fail;
33050 {
33051 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
33052 if (SWIG_arg_fail(2)) SWIG_fail;
33053 }
33054 {
33055 PyThreadState* __tstate = wxPyBeginAllowThreads();
33056 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
33057
33058 wxPyEndAllowThreads(__tstate);
33059 if (PyErr_Occurred()) SWIG_fail;
33060 }
33061 {
33062 resultobj = wxPyMake_wxObject(result, 0);
33063 }
33064 return resultobj;
33065 fail:
33066 return NULL;
33067 }
33068
33069
33070 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
33071 PyObject *resultobj = NULL;
33072 PyObject *result;
33073 char *kwnames[] = {
33074 NULL
33075 };
33076
33077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
33078 {
33079 PyThreadState* __tstate = wxPyBeginAllowThreads();
33080 result = (PyObject *)GetTopLevelWindows();
33081
33082 wxPyEndAllowThreads(__tstate);
33083 if (PyErr_Occurred()) SWIG_fail;
33084 }
33085 resultobj = result;
33086 return resultobj;
33087 fail:
33088 return NULL;
33089 }
33090
33091
33092 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
33093 PyObject *resultobj = NULL;
33094 wxValidator *result;
33095 char *kwnames[] = {
33096 NULL
33097 };
33098
33099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
33100 {
33101 PyThreadState* __tstate = wxPyBeginAllowThreads();
33102 result = (wxValidator *)new wxValidator();
33103
33104 wxPyEndAllowThreads(__tstate);
33105 if (PyErr_Occurred()) SWIG_fail;
33106 }
33107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
33108 return resultobj;
33109 fail:
33110 return NULL;
33111 }
33112
33113
33114 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
33115 PyObject *resultobj = NULL;
33116 wxValidator *arg1 = (wxValidator *) 0 ;
33117 wxValidator *result;
33118 PyObject * obj0 = 0 ;
33119 char *kwnames[] = {
33120 (char *) "self", NULL
33121 };
33122
33123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
33124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33125 if (SWIG_arg_fail(1)) SWIG_fail;
33126 {
33127 PyThreadState* __tstate = wxPyBeginAllowThreads();
33128 result = (wxValidator *)(arg1)->Clone();
33129
33130 wxPyEndAllowThreads(__tstate);
33131 if (PyErr_Occurred()) SWIG_fail;
33132 }
33133 {
33134 resultobj = wxPyMake_wxObject(result, 0);
33135 }
33136 return resultobj;
33137 fail:
33138 return NULL;
33139 }
33140
33141
33142 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
33143 PyObject *resultobj = NULL;
33144 wxValidator *arg1 = (wxValidator *) 0 ;
33145 wxWindow *arg2 = (wxWindow *) 0 ;
33146 bool result;
33147 PyObject * obj0 = 0 ;
33148 PyObject * obj1 = 0 ;
33149 char *kwnames[] = {
33150 (char *) "self",(char *) "parent", NULL
33151 };
33152
33153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
33154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33155 if (SWIG_arg_fail(1)) SWIG_fail;
33156 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33157 if (SWIG_arg_fail(2)) SWIG_fail;
33158 {
33159 PyThreadState* __tstate = wxPyBeginAllowThreads();
33160 result = (bool)(arg1)->Validate(arg2);
33161
33162 wxPyEndAllowThreads(__tstate);
33163 if (PyErr_Occurred()) SWIG_fail;
33164 }
33165 {
33166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33167 }
33168 return resultobj;
33169 fail:
33170 return NULL;
33171 }
33172
33173
33174 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33175 PyObject *resultobj = NULL;
33176 wxValidator *arg1 = (wxValidator *) 0 ;
33177 bool result;
33178 PyObject * obj0 = 0 ;
33179 char *kwnames[] = {
33180 (char *) "self", NULL
33181 };
33182
33183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
33184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33185 if (SWIG_arg_fail(1)) SWIG_fail;
33186 {
33187 PyThreadState* __tstate = wxPyBeginAllowThreads();
33188 result = (bool)(arg1)->TransferToWindow();
33189
33190 wxPyEndAllowThreads(__tstate);
33191 if (PyErr_Occurred()) SWIG_fail;
33192 }
33193 {
33194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33195 }
33196 return resultobj;
33197 fail:
33198 return NULL;
33199 }
33200
33201
33202 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33203 PyObject *resultobj = NULL;
33204 wxValidator *arg1 = (wxValidator *) 0 ;
33205 bool result;
33206 PyObject * obj0 = 0 ;
33207 char *kwnames[] = {
33208 (char *) "self", NULL
33209 };
33210
33211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
33212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33213 if (SWIG_arg_fail(1)) SWIG_fail;
33214 {
33215 PyThreadState* __tstate = wxPyBeginAllowThreads();
33216 result = (bool)(arg1)->TransferFromWindow();
33217
33218 wxPyEndAllowThreads(__tstate);
33219 if (PyErr_Occurred()) SWIG_fail;
33220 }
33221 {
33222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33223 }
33224 return resultobj;
33225 fail:
33226 return NULL;
33227 }
33228
33229
33230 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33231 PyObject *resultobj = NULL;
33232 wxValidator *arg1 = (wxValidator *) 0 ;
33233 wxWindow *result;
33234 PyObject * obj0 = 0 ;
33235 char *kwnames[] = {
33236 (char *) "self", NULL
33237 };
33238
33239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
33240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33241 if (SWIG_arg_fail(1)) SWIG_fail;
33242 {
33243 PyThreadState* __tstate = wxPyBeginAllowThreads();
33244 result = (wxWindow *)(arg1)->GetWindow();
33245
33246 wxPyEndAllowThreads(__tstate);
33247 if (PyErr_Occurred()) SWIG_fail;
33248 }
33249 {
33250 resultobj = wxPyMake_wxObject(result, 0);
33251 }
33252 return resultobj;
33253 fail:
33254 return NULL;
33255 }
33256
33257
33258 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33259 PyObject *resultobj = NULL;
33260 wxValidator *arg1 = (wxValidator *) 0 ;
33261 wxWindow *arg2 = (wxWindow *) 0 ;
33262 PyObject * obj0 = 0 ;
33263 PyObject * obj1 = 0 ;
33264 char *kwnames[] = {
33265 (char *) "self",(char *) "window", NULL
33266 };
33267
33268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
33269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33270 if (SWIG_arg_fail(1)) SWIG_fail;
33271 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33272 if (SWIG_arg_fail(2)) SWIG_fail;
33273 {
33274 PyThreadState* __tstate = wxPyBeginAllowThreads();
33275 (arg1)->SetWindow(arg2);
33276
33277 wxPyEndAllowThreads(__tstate);
33278 if (PyErr_Occurred()) SWIG_fail;
33279 }
33280 Py_INCREF(Py_None); resultobj = Py_None;
33281 return resultobj;
33282 fail:
33283 return NULL;
33284 }
33285
33286
33287 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
33288 PyObject *resultobj = NULL;
33289 bool result;
33290 char *kwnames[] = {
33291 NULL
33292 };
33293
33294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
33295 {
33296 PyThreadState* __tstate = wxPyBeginAllowThreads();
33297 result = (bool)wxValidator::IsSilent();
33298
33299 wxPyEndAllowThreads(__tstate);
33300 if (PyErr_Occurred()) SWIG_fail;
33301 }
33302 {
33303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33304 }
33305 return resultobj;
33306 fail:
33307 return NULL;
33308 }
33309
33310
33311 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
33312 PyObject *resultobj = NULL;
33313 int arg1 = (int) true ;
33314 PyObject * obj0 = 0 ;
33315 char *kwnames[] = {
33316 (char *) "doIt", NULL
33317 };
33318
33319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
33320 if (obj0) {
33321 {
33322 arg1 = static_cast<int >(SWIG_As_int(obj0));
33323 if (SWIG_arg_fail(1)) SWIG_fail;
33324 }
33325 }
33326 {
33327 PyThreadState* __tstate = wxPyBeginAllowThreads();
33328 wxValidator::SetBellOnError(arg1);
33329
33330 wxPyEndAllowThreads(__tstate);
33331 if (PyErr_Occurred()) SWIG_fail;
33332 }
33333 Py_INCREF(Py_None); resultobj = Py_None;
33334 return resultobj;
33335 fail:
33336 return NULL;
33337 }
33338
33339
33340 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
33341 PyObject *obj;
33342 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33343 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
33344 Py_INCREF(obj);
33345 return Py_BuildValue((char *)"");
33346 }
33347 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
33348 PyObject *resultobj = NULL;
33349 wxPyValidator *result;
33350 char *kwnames[] = {
33351 NULL
33352 };
33353
33354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
33355 {
33356 PyThreadState* __tstate = wxPyBeginAllowThreads();
33357 result = (wxPyValidator *)new wxPyValidator();
33358
33359 wxPyEndAllowThreads(__tstate);
33360 if (PyErr_Occurred()) SWIG_fail;
33361 }
33362 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
33363 return resultobj;
33364 fail:
33365 return NULL;
33366 }
33367
33368
33369 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
33370 PyObject *resultobj = NULL;
33371 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
33372 PyObject *arg2 = (PyObject *) 0 ;
33373 PyObject *arg3 = (PyObject *) 0 ;
33374 int arg4 = (int) true ;
33375 PyObject * obj0 = 0 ;
33376 PyObject * obj1 = 0 ;
33377 PyObject * obj2 = 0 ;
33378 PyObject * obj3 = 0 ;
33379 char *kwnames[] = {
33380 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33381 };
33382
33383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
33385 if (SWIG_arg_fail(1)) SWIG_fail;
33386 arg2 = obj1;
33387 arg3 = obj2;
33388 if (obj3) {
33389 {
33390 arg4 = static_cast<int >(SWIG_As_int(obj3));
33391 if (SWIG_arg_fail(4)) SWIG_fail;
33392 }
33393 }
33394 {
33395 PyThreadState* __tstate = wxPyBeginAllowThreads();
33396 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33397
33398 wxPyEndAllowThreads(__tstate);
33399 if (PyErr_Occurred()) SWIG_fail;
33400 }
33401 Py_INCREF(Py_None); resultobj = Py_None;
33402 return resultobj;
33403 fail:
33404 return NULL;
33405 }
33406
33407
33408 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
33409 PyObject *obj;
33410 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33411 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
33412 Py_INCREF(obj);
33413 return Py_BuildValue((char *)"");
33414 }
33415 static int _wrap_DefaultValidator_set(PyObject *) {
33416 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
33417 return 1;
33418 }
33419
33420
33421 static PyObject *_wrap_DefaultValidator_get(void) {
33422 PyObject *pyobj = NULL;
33423
33424 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
33425 return pyobj;
33426 }
33427
33428
33429 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
33430 PyObject *resultobj = NULL;
33431 wxString const &arg1_defvalue = wxPyEmptyString ;
33432 wxString *arg1 = (wxString *) &arg1_defvalue ;
33433 long arg2 = (long) 0 ;
33434 wxMenu *result;
33435 bool temp1 = false ;
33436 PyObject * obj0 = 0 ;
33437 PyObject * obj1 = 0 ;
33438 char *kwnames[] = {
33439 (char *) "title",(char *) "style", NULL
33440 };
33441
33442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
33443 if (obj0) {
33444 {
33445 arg1 = wxString_in_helper(obj0);
33446 if (arg1 == NULL) SWIG_fail;
33447 temp1 = true;
33448 }
33449 }
33450 if (obj1) {
33451 {
33452 arg2 = static_cast<long >(SWIG_As_long(obj1));
33453 if (SWIG_arg_fail(2)) SWIG_fail;
33454 }
33455 }
33456 {
33457 if (!wxPyCheckForApp()) SWIG_fail;
33458 PyThreadState* __tstate = wxPyBeginAllowThreads();
33459 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
33460
33461 wxPyEndAllowThreads(__tstate);
33462 if (PyErr_Occurred()) SWIG_fail;
33463 }
33464 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
33465 {
33466 if (temp1)
33467 delete arg1;
33468 }
33469 return resultobj;
33470 fail:
33471 {
33472 if (temp1)
33473 delete arg1;
33474 }
33475 return NULL;
33476 }
33477
33478
33479 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
33480 PyObject *resultobj = NULL;
33481 wxMenu *arg1 = (wxMenu *) 0 ;
33482 int arg2 ;
33483 wxString *arg3 = 0 ;
33484 wxString const &arg4_defvalue = wxPyEmptyString ;
33485 wxString *arg4 = (wxString *) &arg4_defvalue ;
33486 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33487 wxMenuItem *result;
33488 bool temp3 = false ;
33489 bool temp4 = false ;
33490 PyObject * obj0 = 0 ;
33491 PyObject * obj1 = 0 ;
33492 PyObject * obj2 = 0 ;
33493 PyObject * obj3 = 0 ;
33494 PyObject * obj4 = 0 ;
33495 char *kwnames[] = {
33496 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33497 };
33498
33499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33501 if (SWIG_arg_fail(1)) SWIG_fail;
33502 {
33503 arg2 = static_cast<int >(SWIG_As_int(obj1));
33504 if (SWIG_arg_fail(2)) SWIG_fail;
33505 }
33506 {
33507 arg3 = wxString_in_helper(obj2);
33508 if (arg3 == NULL) SWIG_fail;
33509 temp3 = true;
33510 }
33511 if (obj3) {
33512 {
33513 arg4 = wxString_in_helper(obj3);
33514 if (arg4 == NULL) SWIG_fail;
33515 temp4 = true;
33516 }
33517 }
33518 if (obj4) {
33519 {
33520 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
33521 if (SWIG_arg_fail(5)) SWIG_fail;
33522 }
33523 }
33524 {
33525 PyThreadState* __tstate = wxPyBeginAllowThreads();
33526 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
33527
33528 wxPyEndAllowThreads(__tstate);
33529 if (PyErr_Occurred()) SWIG_fail;
33530 }
33531 {
33532 resultobj = wxPyMake_wxObject(result, 0);
33533 }
33534 {
33535 if (temp3)
33536 delete arg3;
33537 }
33538 {
33539 if (temp4)
33540 delete arg4;
33541 }
33542 return resultobj;
33543 fail:
33544 {
33545 if (temp3)
33546 delete arg3;
33547 }
33548 {
33549 if (temp4)
33550 delete arg4;
33551 }
33552 return NULL;
33553 }
33554
33555
33556 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33557 PyObject *resultobj = NULL;
33558 wxMenu *arg1 = (wxMenu *) 0 ;
33559 wxMenuItem *result;
33560 PyObject * obj0 = 0 ;
33561 char *kwnames[] = {
33562 (char *) "self", NULL
33563 };
33564
33565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
33566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33567 if (SWIG_arg_fail(1)) SWIG_fail;
33568 {
33569 PyThreadState* __tstate = wxPyBeginAllowThreads();
33570 result = (wxMenuItem *)(arg1)->AppendSeparator();
33571
33572 wxPyEndAllowThreads(__tstate);
33573 if (PyErr_Occurred()) SWIG_fail;
33574 }
33575 {
33576 resultobj = wxPyMake_wxObject(result, 0);
33577 }
33578 return resultobj;
33579 fail:
33580 return NULL;
33581 }
33582
33583
33584 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33585 PyObject *resultobj = NULL;
33586 wxMenu *arg1 = (wxMenu *) 0 ;
33587 int arg2 ;
33588 wxString *arg3 = 0 ;
33589 wxString const &arg4_defvalue = wxPyEmptyString ;
33590 wxString *arg4 = (wxString *) &arg4_defvalue ;
33591 wxMenuItem *result;
33592 bool temp3 = false ;
33593 bool temp4 = false ;
33594 PyObject * obj0 = 0 ;
33595 PyObject * obj1 = 0 ;
33596 PyObject * obj2 = 0 ;
33597 PyObject * obj3 = 0 ;
33598 char *kwnames[] = {
33599 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33600 };
33601
33602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33604 if (SWIG_arg_fail(1)) SWIG_fail;
33605 {
33606 arg2 = static_cast<int >(SWIG_As_int(obj1));
33607 if (SWIG_arg_fail(2)) SWIG_fail;
33608 }
33609 {
33610 arg3 = wxString_in_helper(obj2);
33611 if (arg3 == NULL) SWIG_fail;
33612 temp3 = true;
33613 }
33614 if (obj3) {
33615 {
33616 arg4 = wxString_in_helper(obj3);
33617 if (arg4 == NULL) SWIG_fail;
33618 temp4 = true;
33619 }
33620 }
33621 {
33622 PyThreadState* __tstate = wxPyBeginAllowThreads();
33623 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33624
33625 wxPyEndAllowThreads(__tstate);
33626 if (PyErr_Occurred()) SWIG_fail;
33627 }
33628 {
33629 resultobj = wxPyMake_wxObject(result, 0);
33630 }
33631 {
33632 if (temp3)
33633 delete arg3;
33634 }
33635 {
33636 if (temp4)
33637 delete arg4;
33638 }
33639 return resultobj;
33640 fail:
33641 {
33642 if (temp3)
33643 delete arg3;
33644 }
33645 {
33646 if (temp4)
33647 delete arg4;
33648 }
33649 return NULL;
33650 }
33651
33652
33653 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33654 PyObject *resultobj = NULL;
33655 wxMenu *arg1 = (wxMenu *) 0 ;
33656 int arg2 ;
33657 wxString *arg3 = 0 ;
33658 wxString const &arg4_defvalue = wxPyEmptyString ;
33659 wxString *arg4 = (wxString *) &arg4_defvalue ;
33660 wxMenuItem *result;
33661 bool temp3 = false ;
33662 bool temp4 = false ;
33663 PyObject * obj0 = 0 ;
33664 PyObject * obj1 = 0 ;
33665 PyObject * obj2 = 0 ;
33666 PyObject * obj3 = 0 ;
33667 char *kwnames[] = {
33668 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33669 };
33670
33671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33673 if (SWIG_arg_fail(1)) SWIG_fail;
33674 {
33675 arg2 = static_cast<int >(SWIG_As_int(obj1));
33676 if (SWIG_arg_fail(2)) SWIG_fail;
33677 }
33678 {
33679 arg3 = wxString_in_helper(obj2);
33680 if (arg3 == NULL) SWIG_fail;
33681 temp3 = true;
33682 }
33683 if (obj3) {
33684 {
33685 arg4 = wxString_in_helper(obj3);
33686 if (arg4 == NULL) SWIG_fail;
33687 temp4 = true;
33688 }
33689 }
33690 {
33691 PyThreadState* __tstate = wxPyBeginAllowThreads();
33692 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33693
33694 wxPyEndAllowThreads(__tstate);
33695 if (PyErr_Occurred()) SWIG_fail;
33696 }
33697 {
33698 resultobj = wxPyMake_wxObject(result, 0);
33699 }
33700 {
33701 if (temp3)
33702 delete arg3;
33703 }
33704 {
33705 if (temp4)
33706 delete arg4;
33707 }
33708 return resultobj;
33709 fail:
33710 {
33711 if (temp3)
33712 delete arg3;
33713 }
33714 {
33715 if (temp4)
33716 delete arg4;
33717 }
33718 return NULL;
33719 }
33720
33721
33722 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33723 PyObject *resultobj = NULL;
33724 wxMenu *arg1 = (wxMenu *) 0 ;
33725 int arg2 ;
33726 wxString *arg3 = 0 ;
33727 wxMenu *arg4 = (wxMenu *) 0 ;
33728 wxString const &arg5_defvalue = wxPyEmptyString ;
33729 wxString *arg5 = (wxString *) &arg5_defvalue ;
33730 wxMenuItem *result;
33731 bool temp3 = false ;
33732 bool temp5 = false ;
33733 PyObject * obj0 = 0 ;
33734 PyObject * obj1 = 0 ;
33735 PyObject * obj2 = 0 ;
33736 PyObject * obj3 = 0 ;
33737 PyObject * obj4 = 0 ;
33738 char *kwnames[] = {
33739 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33740 };
33741
33742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33744 if (SWIG_arg_fail(1)) SWIG_fail;
33745 {
33746 arg2 = static_cast<int >(SWIG_As_int(obj1));
33747 if (SWIG_arg_fail(2)) SWIG_fail;
33748 }
33749 {
33750 arg3 = wxString_in_helper(obj2);
33751 if (arg3 == NULL) SWIG_fail;
33752 temp3 = true;
33753 }
33754 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33755 if (SWIG_arg_fail(4)) SWIG_fail;
33756 if (obj4) {
33757 {
33758 arg5 = wxString_in_helper(obj4);
33759 if (arg5 == NULL) SWIG_fail;
33760 temp5 = true;
33761 }
33762 }
33763 {
33764 PyThreadState* __tstate = wxPyBeginAllowThreads();
33765 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33766
33767 wxPyEndAllowThreads(__tstate);
33768 if (PyErr_Occurred()) SWIG_fail;
33769 }
33770 {
33771 resultobj = wxPyMake_wxObject(result, 0);
33772 }
33773 {
33774 if (temp3)
33775 delete arg3;
33776 }
33777 {
33778 if (temp5)
33779 delete arg5;
33780 }
33781 return resultobj;
33782 fail:
33783 {
33784 if (temp3)
33785 delete arg3;
33786 }
33787 {
33788 if (temp5)
33789 delete arg5;
33790 }
33791 return NULL;
33792 }
33793
33794
33795 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33796 PyObject *resultobj = NULL;
33797 wxMenu *arg1 = (wxMenu *) 0 ;
33798 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33799 wxMenuItem *result;
33800 PyObject * obj0 = 0 ;
33801 PyObject * obj1 = 0 ;
33802 char *kwnames[] = {
33803 (char *) "self",(char *) "item", NULL
33804 };
33805
33806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33808 if (SWIG_arg_fail(1)) SWIG_fail;
33809 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33810 if (SWIG_arg_fail(2)) SWIG_fail;
33811 {
33812 PyThreadState* __tstate = wxPyBeginAllowThreads();
33813 result = (wxMenuItem *)(arg1)->Append(arg2);
33814
33815 wxPyEndAllowThreads(__tstate);
33816 if (PyErr_Occurred()) SWIG_fail;
33817 }
33818 {
33819 resultobj = wxPyMake_wxObject(result, 0);
33820 }
33821 return resultobj;
33822 fail:
33823 return NULL;
33824 }
33825
33826
33827 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33828 PyObject *resultobj = NULL;
33829 wxMenu *arg1 = (wxMenu *) 0 ;
33830 PyObject * obj0 = 0 ;
33831 char *kwnames[] = {
33832 (char *) "self", NULL
33833 };
33834
33835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33837 if (SWIG_arg_fail(1)) SWIG_fail;
33838 {
33839 PyThreadState* __tstate = wxPyBeginAllowThreads();
33840 (arg1)->Break();
33841
33842 wxPyEndAllowThreads(__tstate);
33843 if (PyErr_Occurred()) SWIG_fail;
33844 }
33845 Py_INCREF(Py_None); resultobj = Py_None;
33846 return resultobj;
33847 fail:
33848 return NULL;
33849 }
33850
33851
33852 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33853 PyObject *resultobj = NULL;
33854 wxMenu *arg1 = (wxMenu *) 0 ;
33855 size_t arg2 ;
33856 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33857 wxMenuItem *result;
33858 PyObject * obj0 = 0 ;
33859 PyObject * obj1 = 0 ;
33860 PyObject * obj2 = 0 ;
33861 char *kwnames[] = {
33862 (char *) "self",(char *) "pos",(char *) "item", NULL
33863 };
33864
33865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33867 if (SWIG_arg_fail(1)) SWIG_fail;
33868 {
33869 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
33870 if (SWIG_arg_fail(2)) SWIG_fail;
33871 }
33872 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33873 if (SWIG_arg_fail(3)) SWIG_fail;
33874 {
33875 PyThreadState* __tstate = wxPyBeginAllowThreads();
33876 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33877
33878 wxPyEndAllowThreads(__tstate);
33879 if (PyErr_Occurred()) SWIG_fail;
33880 }
33881 {
33882 resultobj = wxPyMake_wxObject(result, 0);
33883 }
33884 return resultobj;
33885 fail:
33886 return NULL;
33887 }
33888
33889
33890 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33891 PyObject *resultobj = NULL;
33892 wxMenu *arg1 = (wxMenu *) 0 ;
33893 size_t arg2 ;
33894 int arg3 ;
33895 wxString *arg4 = 0 ;
33896 wxString const &arg5_defvalue = wxPyEmptyString ;
33897 wxString *arg5 = (wxString *) &arg5_defvalue ;
33898 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33899 wxMenuItem *result;
33900 bool temp4 = false ;
33901 bool temp5 = false ;
33902 PyObject * obj0 = 0 ;
33903 PyObject * obj1 = 0 ;
33904 PyObject * obj2 = 0 ;
33905 PyObject * obj3 = 0 ;
33906 PyObject * obj4 = 0 ;
33907 PyObject * obj5 = 0 ;
33908 char *kwnames[] = {
33909 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33910 };
33911
33912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33914 if (SWIG_arg_fail(1)) SWIG_fail;
33915 {
33916 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
33917 if (SWIG_arg_fail(2)) SWIG_fail;
33918 }
33919 {
33920 arg3 = static_cast<int >(SWIG_As_int(obj2));
33921 if (SWIG_arg_fail(3)) SWIG_fail;
33922 }
33923 {
33924 arg4 = wxString_in_helper(obj3);
33925 if (arg4 == NULL) SWIG_fail;
33926 temp4 = true;
33927 }
33928 if (obj4) {
33929 {
33930 arg5 = wxString_in_helper(obj4);
33931 if (arg5 == NULL) SWIG_fail;
33932 temp5 = true;
33933 }
33934 }
33935 if (obj5) {
33936 {
33937 arg6 = static_cast<wxItemKind >(SWIG_As_int(obj5));
33938 if (SWIG_arg_fail(6)) SWIG_fail;
33939 }
33940 }
33941 {
33942 PyThreadState* __tstate = wxPyBeginAllowThreads();
33943 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
33944
33945 wxPyEndAllowThreads(__tstate);
33946 if (PyErr_Occurred()) SWIG_fail;
33947 }
33948 {
33949 resultobj = wxPyMake_wxObject(result, 0);
33950 }
33951 {
33952 if (temp4)
33953 delete arg4;
33954 }
33955 {
33956 if (temp5)
33957 delete arg5;
33958 }
33959 return resultobj;
33960 fail:
33961 {
33962 if (temp4)
33963 delete arg4;
33964 }
33965 {
33966 if (temp5)
33967 delete arg5;
33968 }
33969 return NULL;
33970 }
33971
33972
33973 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33974 PyObject *resultobj = NULL;
33975 wxMenu *arg1 = (wxMenu *) 0 ;
33976 size_t arg2 ;
33977 wxMenuItem *result;
33978 PyObject * obj0 = 0 ;
33979 PyObject * obj1 = 0 ;
33980 char *kwnames[] = {
33981 (char *) "self",(char *) "pos", NULL
33982 };
33983
33984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33986 if (SWIG_arg_fail(1)) SWIG_fail;
33987 {
33988 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
33989 if (SWIG_arg_fail(2)) SWIG_fail;
33990 }
33991 {
33992 PyThreadState* __tstate = wxPyBeginAllowThreads();
33993 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33994
33995 wxPyEndAllowThreads(__tstate);
33996 if (PyErr_Occurred()) SWIG_fail;
33997 }
33998 {
33999 resultobj = wxPyMake_wxObject(result, 0);
34000 }
34001 return resultobj;
34002 fail:
34003 return NULL;
34004 }
34005
34006
34007 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34008 PyObject *resultobj = NULL;
34009 wxMenu *arg1 = (wxMenu *) 0 ;
34010 size_t arg2 ;
34011 int arg3 ;
34012 wxString *arg4 = 0 ;
34013 wxString const &arg5_defvalue = wxPyEmptyString ;
34014 wxString *arg5 = (wxString *) &arg5_defvalue ;
34015 wxMenuItem *result;
34016 bool temp4 = false ;
34017 bool temp5 = false ;
34018 PyObject * obj0 = 0 ;
34019 PyObject * obj1 = 0 ;
34020 PyObject * obj2 = 0 ;
34021 PyObject * obj3 = 0 ;
34022 PyObject * obj4 = 0 ;
34023 char *kwnames[] = {
34024 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
34025 };
34026
34027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34029 if (SWIG_arg_fail(1)) SWIG_fail;
34030 {
34031 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34032 if (SWIG_arg_fail(2)) SWIG_fail;
34033 }
34034 {
34035 arg3 = static_cast<int >(SWIG_As_int(obj2));
34036 if (SWIG_arg_fail(3)) SWIG_fail;
34037 }
34038 {
34039 arg4 = wxString_in_helper(obj3);
34040 if (arg4 == NULL) SWIG_fail;
34041 temp4 = true;
34042 }
34043 if (obj4) {
34044 {
34045 arg5 = wxString_in_helper(obj4);
34046 if (arg5 == NULL) SWIG_fail;
34047 temp5 = true;
34048 }
34049 }
34050 {
34051 PyThreadState* __tstate = wxPyBeginAllowThreads();
34052 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
34053
34054 wxPyEndAllowThreads(__tstate);
34055 if (PyErr_Occurred()) SWIG_fail;
34056 }
34057 {
34058 resultobj = wxPyMake_wxObject(result, 0);
34059 }
34060 {
34061 if (temp4)
34062 delete arg4;
34063 }
34064 {
34065 if (temp5)
34066 delete arg5;
34067 }
34068 return resultobj;
34069 fail:
34070 {
34071 if (temp4)
34072 delete arg4;
34073 }
34074 {
34075 if (temp5)
34076 delete arg5;
34077 }
34078 return NULL;
34079 }
34080
34081
34082 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34083 PyObject *resultobj = NULL;
34084 wxMenu *arg1 = (wxMenu *) 0 ;
34085 size_t arg2 ;
34086 int arg3 ;
34087 wxString *arg4 = 0 ;
34088 wxString const &arg5_defvalue = wxPyEmptyString ;
34089 wxString *arg5 = (wxString *) &arg5_defvalue ;
34090 wxMenuItem *result;
34091 bool temp4 = false ;
34092 bool temp5 = false ;
34093 PyObject * obj0 = 0 ;
34094 PyObject * obj1 = 0 ;
34095 PyObject * obj2 = 0 ;
34096 PyObject * obj3 = 0 ;
34097 PyObject * obj4 = 0 ;
34098 char *kwnames[] = {
34099 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
34100 };
34101
34102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34104 if (SWIG_arg_fail(1)) SWIG_fail;
34105 {
34106 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34107 if (SWIG_arg_fail(2)) SWIG_fail;
34108 }
34109 {
34110 arg3 = static_cast<int >(SWIG_As_int(obj2));
34111 if (SWIG_arg_fail(3)) SWIG_fail;
34112 }
34113 {
34114 arg4 = wxString_in_helper(obj3);
34115 if (arg4 == NULL) SWIG_fail;
34116 temp4 = true;
34117 }
34118 if (obj4) {
34119 {
34120 arg5 = wxString_in_helper(obj4);
34121 if (arg5 == NULL) SWIG_fail;
34122 temp5 = true;
34123 }
34124 }
34125 {
34126 PyThreadState* __tstate = wxPyBeginAllowThreads();
34127 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
34128
34129 wxPyEndAllowThreads(__tstate);
34130 if (PyErr_Occurred()) SWIG_fail;
34131 }
34132 {
34133 resultobj = wxPyMake_wxObject(result, 0);
34134 }
34135 {
34136 if (temp4)
34137 delete arg4;
34138 }
34139 {
34140 if (temp5)
34141 delete arg5;
34142 }
34143 return resultobj;
34144 fail:
34145 {
34146 if (temp4)
34147 delete arg4;
34148 }
34149 {
34150 if (temp5)
34151 delete arg5;
34152 }
34153 return NULL;
34154 }
34155
34156
34157 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34158 PyObject *resultobj = NULL;
34159 wxMenu *arg1 = (wxMenu *) 0 ;
34160 size_t arg2 ;
34161 int arg3 ;
34162 wxString *arg4 = 0 ;
34163 wxMenu *arg5 = (wxMenu *) 0 ;
34164 wxString const &arg6_defvalue = wxPyEmptyString ;
34165 wxString *arg6 = (wxString *) &arg6_defvalue ;
34166 wxMenuItem *result;
34167 bool temp4 = false ;
34168 bool temp6 = false ;
34169 PyObject * obj0 = 0 ;
34170 PyObject * obj1 = 0 ;
34171 PyObject * obj2 = 0 ;
34172 PyObject * obj3 = 0 ;
34173 PyObject * obj4 = 0 ;
34174 PyObject * obj5 = 0 ;
34175 char *kwnames[] = {
34176 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34177 };
34178
34179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
34180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34181 if (SWIG_arg_fail(1)) SWIG_fail;
34182 {
34183 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34184 if (SWIG_arg_fail(2)) SWIG_fail;
34185 }
34186 {
34187 arg3 = static_cast<int >(SWIG_As_int(obj2));
34188 if (SWIG_arg_fail(3)) SWIG_fail;
34189 }
34190 {
34191 arg4 = wxString_in_helper(obj3);
34192 if (arg4 == NULL) SWIG_fail;
34193 temp4 = true;
34194 }
34195 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34196 if (SWIG_arg_fail(5)) SWIG_fail;
34197 if (obj5) {
34198 {
34199 arg6 = wxString_in_helper(obj5);
34200 if (arg6 == NULL) SWIG_fail;
34201 temp6 = true;
34202 }
34203 }
34204 {
34205 PyThreadState* __tstate = wxPyBeginAllowThreads();
34206 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
34207
34208 wxPyEndAllowThreads(__tstate);
34209 if (PyErr_Occurred()) SWIG_fail;
34210 }
34211 {
34212 resultobj = wxPyMake_wxObject(result, 0);
34213 }
34214 {
34215 if (temp4)
34216 delete arg4;
34217 }
34218 {
34219 if (temp6)
34220 delete arg6;
34221 }
34222 return resultobj;
34223 fail:
34224 {
34225 if (temp4)
34226 delete arg4;
34227 }
34228 {
34229 if (temp6)
34230 delete arg6;
34231 }
34232 return NULL;
34233 }
34234
34235
34236 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
34237 PyObject *resultobj = NULL;
34238 wxMenu *arg1 = (wxMenu *) 0 ;
34239 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34240 wxMenuItem *result;
34241 PyObject * obj0 = 0 ;
34242 PyObject * obj1 = 0 ;
34243 char *kwnames[] = {
34244 (char *) "self",(char *) "item", NULL
34245 };
34246
34247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
34248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34249 if (SWIG_arg_fail(1)) SWIG_fail;
34250 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34251 if (SWIG_arg_fail(2)) SWIG_fail;
34252 {
34253 PyThreadState* __tstate = wxPyBeginAllowThreads();
34254 result = (wxMenuItem *)(arg1)->Prepend(arg2);
34255
34256 wxPyEndAllowThreads(__tstate);
34257 if (PyErr_Occurred()) SWIG_fail;
34258 }
34259 {
34260 resultobj = wxPyMake_wxObject(result, 0);
34261 }
34262 return resultobj;
34263 fail:
34264 return NULL;
34265 }
34266
34267
34268 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
34269 PyObject *resultobj = NULL;
34270 wxMenu *arg1 = (wxMenu *) 0 ;
34271 int arg2 ;
34272 wxString *arg3 = 0 ;
34273 wxString const &arg4_defvalue = wxPyEmptyString ;
34274 wxString *arg4 = (wxString *) &arg4_defvalue ;
34275 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
34276 wxMenuItem *result;
34277 bool temp3 = false ;
34278 bool temp4 = false ;
34279 PyObject * obj0 = 0 ;
34280 PyObject * obj1 = 0 ;
34281 PyObject * obj2 = 0 ;
34282 PyObject * obj3 = 0 ;
34283 PyObject * obj4 = 0 ;
34284 char *kwnames[] = {
34285 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
34286 };
34287
34288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34290 if (SWIG_arg_fail(1)) SWIG_fail;
34291 {
34292 arg2 = static_cast<int >(SWIG_As_int(obj1));
34293 if (SWIG_arg_fail(2)) SWIG_fail;
34294 }
34295 {
34296 arg3 = wxString_in_helper(obj2);
34297 if (arg3 == NULL) SWIG_fail;
34298 temp3 = true;
34299 }
34300 if (obj3) {
34301 {
34302 arg4 = wxString_in_helper(obj3);
34303 if (arg4 == NULL) SWIG_fail;
34304 temp4 = true;
34305 }
34306 }
34307 if (obj4) {
34308 {
34309 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
34310 if (SWIG_arg_fail(5)) SWIG_fail;
34311 }
34312 }
34313 {
34314 PyThreadState* __tstate = wxPyBeginAllowThreads();
34315 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
34316
34317 wxPyEndAllowThreads(__tstate);
34318 if (PyErr_Occurred()) SWIG_fail;
34319 }
34320 {
34321 resultobj = wxPyMake_wxObject(result, 0);
34322 }
34323 {
34324 if (temp3)
34325 delete arg3;
34326 }
34327 {
34328 if (temp4)
34329 delete arg4;
34330 }
34331 return resultobj;
34332 fail:
34333 {
34334 if (temp3)
34335 delete arg3;
34336 }
34337 {
34338 if (temp4)
34339 delete arg4;
34340 }
34341 return NULL;
34342 }
34343
34344
34345 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
34346 PyObject *resultobj = NULL;
34347 wxMenu *arg1 = (wxMenu *) 0 ;
34348 wxMenuItem *result;
34349 PyObject * obj0 = 0 ;
34350 char *kwnames[] = {
34351 (char *) "self", NULL
34352 };
34353
34354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
34355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34356 if (SWIG_arg_fail(1)) SWIG_fail;
34357 {
34358 PyThreadState* __tstate = wxPyBeginAllowThreads();
34359 result = (wxMenuItem *)(arg1)->PrependSeparator();
34360
34361 wxPyEndAllowThreads(__tstate);
34362 if (PyErr_Occurred()) SWIG_fail;
34363 }
34364 {
34365 resultobj = wxPyMake_wxObject(result, 0);
34366 }
34367 return resultobj;
34368 fail:
34369 return NULL;
34370 }
34371
34372
34373 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34374 PyObject *resultobj = NULL;
34375 wxMenu *arg1 = (wxMenu *) 0 ;
34376 int arg2 ;
34377 wxString *arg3 = 0 ;
34378 wxString const &arg4_defvalue = wxPyEmptyString ;
34379 wxString *arg4 = (wxString *) &arg4_defvalue ;
34380 wxMenuItem *result;
34381 bool temp3 = false ;
34382 bool temp4 = false ;
34383 PyObject * obj0 = 0 ;
34384 PyObject * obj1 = 0 ;
34385 PyObject * obj2 = 0 ;
34386 PyObject * obj3 = 0 ;
34387 char *kwnames[] = {
34388 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34389 };
34390
34391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34393 if (SWIG_arg_fail(1)) SWIG_fail;
34394 {
34395 arg2 = static_cast<int >(SWIG_As_int(obj1));
34396 if (SWIG_arg_fail(2)) SWIG_fail;
34397 }
34398 {
34399 arg3 = wxString_in_helper(obj2);
34400 if (arg3 == NULL) SWIG_fail;
34401 temp3 = true;
34402 }
34403 if (obj3) {
34404 {
34405 arg4 = wxString_in_helper(obj3);
34406 if (arg4 == NULL) SWIG_fail;
34407 temp4 = true;
34408 }
34409 }
34410 {
34411 PyThreadState* __tstate = wxPyBeginAllowThreads();
34412 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34413
34414 wxPyEndAllowThreads(__tstate);
34415 if (PyErr_Occurred()) SWIG_fail;
34416 }
34417 {
34418 resultobj = wxPyMake_wxObject(result, 0);
34419 }
34420 {
34421 if (temp3)
34422 delete arg3;
34423 }
34424 {
34425 if (temp4)
34426 delete arg4;
34427 }
34428 return resultobj;
34429 fail:
34430 {
34431 if (temp3)
34432 delete arg3;
34433 }
34434 {
34435 if (temp4)
34436 delete arg4;
34437 }
34438 return NULL;
34439 }
34440
34441
34442 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34443 PyObject *resultobj = NULL;
34444 wxMenu *arg1 = (wxMenu *) 0 ;
34445 int arg2 ;
34446 wxString *arg3 = 0 ;
34447 wxString const &arg4_defvalue = wxPyEmptyString ;
34448 wxString *arg4 = (wxString *) &arg4_defvalue ;
34449 wxMenuItem *result;
34450 bool temp3 = false ;
34451 bool temp4 = false ;
34452 PyObject * obj0 = 0 ;
34453 PyObject * obj1 = 0 ;
34454 PyObject * obj2 = 0 ;
34455 PyObject * obj3 = 0 ;
34456 char *kwnames[] = {
34457 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34458 };
34459
34460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34462 if (SWIG_arg_fail(1)) SWIG_fail;
34463 {
34464 arg2 = static_cast<int >(SWIG_As_int(obj1));
34465 if (SWIG_arg_fail(2)) SWIG_fail;
34466 }
34467 {
34468 arg3 = wxString_in_helper(obj2);
34469 if (arg3 == NULL) SWIG_fail;
34470 temp3 = true;
34471 }
34472 if (obj3) {
34473 {
34474 arg4 = wxString_in_helper(obj3);
34475 if (arg4 == NULL) SWIG_fail;
34476 temp4 = true;
34477 }
34478 }
34479 {
34480 PyThreadState* __tstate = wxPyBeginAllowThreads();
34481 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34482
34483 wxPyEndAllowThreads(__tstate);
34484 if (PyErr_Occurred()) SWIG_fail;
34485 }
34486 {
34487 resultobj = wxPyMake_wxObject(result, 0);
34488 }
34489 {
34490 if (temp3)
34491 delete arg3;
34492 }
34493 {
34494 if (temp4)
34495 delete arg4;
34496 }
34497 return resultobj;
34498 fail:
34499 {
34500 if (temp3)
34501 delete arg3;
34502 }
34503 {
34504 if (temp4)
34505 delete arg4;
34506 }
34507 return NULL;
34508 }
34509
34510
34511 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34512 PyObject *resultobj = NULL;
34513 wxMenu *arg1 = (wxMenu *) 0 ;
34514 int arg2 ;
34515 wxString *arg3 = 0 ;
34516 wxMenu *arg4 = (wxMenu *) 0 ;
34517 wxString const &arg5_defvalue = wxPyEmptyString ;
34518 wxString *arg5 = (wxString *) &arg5_defvalue ;
34519 wxMenuItem *result;
34520 bool temp3 = false ;
34521 bool temp5 = false ;
34522 PyObject * obj0 = 0 ;
34523 PyObject * obj1 = 0 ;
34524 PyObject * obj2 = 0 ;
34525 PyObject * obj3 = 0 ;
34526 PyObject * obj4 = 0 ;
34527 char *kwnames[] = {
34528 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34529 };
34530
34531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34533 if (SWIG_arg_fail(1)) SWIG_fail;
34534 {
34535 arg2 = static_cast<int >(SWIG_As_int(obj1));
34536 if (SWIG_arg_fail(2)) SWIG_fail;
34537 }
34538 {
34539 arg3 = wxString_in_helper(obj2);
34540 if (arg3 == NULL) SWIG_fail;
34541 temp3 = true;
34542 }
34543 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34544 if (SWIG_arg_fail(4)) SWIG_fail;
34545 if (obj4) {
34546 {
34547 arg5 = wxString_in_helper(obj4);
34548 if (arg5 == NULL) SWIG_fail;
34549 temp5 = true;
34550 }
34551 }
34552 {
34553 PyThreadState* __tstate = wxPyBeginAllowThreads();
34554 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
34555
34556 wxPyEndAllowThreads(__tstate);
34557 if (PyErr_Occurred()) SWIG_fail;
34558 }
34559 {
34560 resultobj = wxPyMake_wxObject(result, 0);
34561 }
34562 {
34563 if (temp3)
34564 delete arg3;
34565 }
34566 {
34567 if (temp5)
34568 delete arg5;
34569 }
34570 return resultobj;
34571 fail:
34572 {
34573 if (temp3)
34574 delete arg3;
34575 }
34576 {
34577 if (temp5)
34578 delete arg5;
34579 }
34580 return NULL;
34581 }
34582
34583
34584 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34585 PyObject *resultobj = NULL;
34586 wxMenu *arg1 = (wxMenu *) 0 ;
34587 int arg2 ;
34588 wxMenuItem *result;
34589 PyObject * obj0 = 0 ;
34590 PyObject * obj1 = 0 ;
34591 char *kwnames[] = {
34592 (char *) "self",(char *) "id", NULL
34593 };
34594
34595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
34596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34597 if (SWIG_arg_fail(1)) SWIG_fail;
34598 {
34599 arg2 = static_cast<int >(SWIG_As_int(obj1));
34600 if (SWIG_arg_fail(2)) SWIG_fail;
34601 }
34602 {
34603 PyThreadState* __tstate = wxPyBeginAllowThreads();
34604 result = (wxMenuItem *)(arg1)->Remove(arg2);
34605
34606 wxPyEndAllowThreads(__tstate);
34607 if (PyErr_Occurred()) SWIG_fail;
34608 }
34609 {
34610 resultobj = wxPyMake_wxObject(result, 0);
34611 }
34612 return resultobj;
34613 fail:
34614 return NULL;
34615 }
34616
34617
34618 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
34619 PyObject *resultobj = NULL;
34620 wxMenu *arg1 = (wxMenu *) 0 ;
34621 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34622 wxMenuItem *result;
34623 PyObject * obj0 = 0 ;
34624 PyObject * obj1 = 0 ;
34625 char *kwnames[] = {
34626 (char *) "self",(char *) "item", NULL
34627 };
34628
34629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
34630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34631 if (SWIG_arg_fail(1)) SWIG_fail;
34632 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34633 if (SWIG_arg_fail(2)) SWIG_fail;
34634 {
34635 PyThreadState* __tstate = wxPyBeginAllowThreads();
34636 result = (wxMenuItem *)(arg1)->Remove(arg2);
34637
34638 wxPyEndAllowThreads(__tstate);
34639 if (PyErr_Occurred()) SWIG_fail;
34640 }
34641 {
34642 resultobj = wxPyMake_wxObject(result, 0);
34643 }
34644 return resultobj;
34645 fail:
34646 return NULL;
34647 }
34648
34649
34650 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
34651 PyObject *resultobj = NULL;
34652 wxMenu *arg1 = (wxMenu *) 0 ;
34653 int arg2 ;
34654 bool result;
34655 PyObject * obj0 = 0 ;
34656 PyObject * obj1 = 0 ;
34657 char *kwnames[] = {
34658 (char *) "self",(char *) "id", NULL
34659 };
34660
34661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
34662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34663 if (SWIG_arg_fail(1)) SWIG_fail;
34664 {
34665 arg2 = static_cast<int >(SWIG_As_int(obj1));
34666 if (SWIG_arg_fail(2)) SWIG_fail;
34667 }
34668 {
34669 PyThreadState* __tstate = wxPyBeginAllowThreads();
34670 result = (bool)(arg1)->Delete(arg2);
34671
34672 wxPyEndAllowThreads(__tstate);
34673 if (PyErr_Occurred()) SWIG_fail;
34674 }
34675 {
34676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34677 }
34678 return resultobj;
34679 fail:
34680 return NULL;
34681 }
34682
34683
34684 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
34685 PyObject *resultobj = NULL;
34686 wxMenu *arg1 = (wxMenu *) 0 ;
34687 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34688 bool result;
34689 PyObject * obj0 = 0 ;
34690 PyObject * obj1 = 0 ;
34691 char *kwnames[] = {
34692 (char *) "self",(char *) "item", NULL
34693 };
34694
34695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
34696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34697 if (SWIG_arg_fail(1)) SWIG_fail;
34698 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34699 if (SWIG_arg_fail(2)) SWIG_fail;
34700 {
34701 PyThreadState* __tstate = wxPyBeginAllowThreads();
34702 result = (bool)(arg1)->Delete(arg2);
34703
34704 wxPyEndAllowThreads(__tstate);
34705 if (PyErr_Occurred()) SWIG_fail;
34706 }
34707 {
34708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34709 }
34710 return resultobj;
34711 fail:
34712 return NULL;
34713 }
34714
34715
34716 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
34717 PyObject *resultobj = NULL;
34718 wxMenu *arg1 = (wxMenu *) 0 ;
34719 PyObject * obj0 = 0 ;
34720 char *kwnames[] = {
34721 (char *) "self", NULL
34722 };
34723
34724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
34725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34726 if (SWIG_arg_fail(1)) SWIG_fail;
34727 {
34728 PyThreadState* __tstate = wxPyBeginAllowThreads();
34729 wxMenu_Destroy(arg1);
34730
34731 wxPyEndAllowThreads(__tstate);
34732 if (PyErr_Occurred()) SWIG_fail;
34733 }
34734 Py_INCREF(Py_None); resultobj = Py_None;
34735 return resultobj;
34736 fail:
34737 return NULL;
34738 }
34739
34740
34741 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
34742 PyObject *resultobj = NULL;
34743 wxMenu *arg1 = (wxMenu *) 0 ;
34744 int arg2 ;
34745 bool result;
34746 PyObject * obj0 = 0 ;
34747 PyObject * obj1 = 0 ;
34748 char *kwnames[] = {
34749 (char *) "self",(char *) "id", NULL
34750 };
34751
34752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
34753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34754 if (SWIG_arg_fail(1)) SWIG_fail;
34755 {
34756 arg2 = static_cast<int >(SWIG_As_int(obj1));
34757 if (SWIG_arg_fail(2)) SWIG_fail;
34758 }
34759 {
34760 PyThreadState* __tstate = wxPyBeginAllowThreads();
34761 result = (bool)(arg1)->Destroy(arg2);
34762
34763 wxPyEndAllowThreads(__tstate);
34764 if (PyErr_Occurred()) SWIG_fail;
34765 }
34766 {
34767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34768 }
34769 return resultobj;
34770 fail:
34771 return NULL;
34772 }
34773
34774
34775 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34776 PyObject *resultobj = NULL;
34777 wxMenu *arg1 = (wxMenu *) 0 ;
34778 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34779 bool result;
34780 PyObject * obj0 = 0 ;
34781 PyObject * obj1 = 0 ;
34782 char *kwnames[] = {
34783 (char *) "self",(char *) "item", NULL
34784 };
34785
34786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34788 if (SWIG_arg_fail(1)) SWIG_fail;
34789 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34790 if (SWIG_arg_fail(2)) SWIG_fail;
34791 {
34792 PyThreadState* __tstate = wxPyBeginAllowThreads();
34793 result = (bool)(arg1)->Destroy(arg2);
34794
34795 wxPyEndAllowThreads(__tstate);
34796 if (PyErr_Occurred()) SWIG_fail;
34797 }
34798 {
34799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34800 }
34801 return resultobj;
34802 fail:
34803 return NULL;
34804 }
34805
34806
34807 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34808 PyObject *resultobj = NULL;
34809 wxMenu *arg1 = (wxMenu *) 0 ;
34810 size_t result;
34811 PyObject * obj0 = 0 ;
34812 char *kwnames[] = {
34813 (char *) "self", NULL
34814 };
34815
34816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34818 if (SWIG_arg_fail(1)) SWIG_fail;
34819 {
34820 PyThreadState* __tstate = wxPyBeginAllowThreads();
34821 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34822
34823 wxPyEndAllowThreads(__tstate);
34824 if (PyErr_Occurred()) SWIG_fail;
34825 }
34826 {
34827 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
34828 }
34829 return resultobj;
34830 fail:
34831 return NULL;
34832 }
34833
34834
34835 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34836 PyObject *resultobj = NULL;
34837 wxMenu *arg1 = (wxMenu *) 0 ;
34838 PyObject *result;
34839 PyObject * obj0 = 0 ;
34840 char *kwnames[] = {
34841 (char *) "self", NULL
34842 };
34843
34844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34846 if (SWIG_arg_fail(1)) SWIG_fail;
34847 {
34848 PyThreadState* __tstate = wxPyBeginAllowThreads();
34849 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34850
34851 wxPyEndAllowThreads(__tstate);
34852 if (PyErr_Occurred()) SWIG_fail;
34853 }
34854 resultobj = result;
34855 return resultobj;
34856 fail:
34857 return NULL;
34858 }
34859
34860
34861 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34862 PyObject *resultobj = NULL;
34863 wxMenu *arg1 = (wxMenu *) 0 ;
34864 wxString *arg2 = 0 ;
34865 int result;
34866 bool temp2 = false ;
34867 PyObject * obj0 = 0 ;
34868 PyObject * obj1 = 0 ;
34869 char *kwnames[] = {
34870 (char *) "self",(char *) "item", NULL
34871 };
34872
34873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34875 if (SWIG_arg_fail(1)) SWIG_fail;
34876 {
34877 arg2 = wxString_in_helper(obj1);
34878 if (arg2 == NULL) SWIG_fail;
34879 temp2 = true;
34880 }
34881 {
34882 PyThreadState* __tstate = wxPyBeginAllowThreads();
34883 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34884
34885 wxPyEndAllowThreads(__tstate);
34886 if (PyErr_Occurred()) SWIG_fail;
34887 }
34888 {
34889 resultobj = SWIG_From_int(static_cast<int >(result));
34890 }
34891 {
34892 if (temp2)
34893 delete arg2;
34894 }
34895 return resultobj;
34896 fail:
34897 {
34898 if (temp2)
34899 delete arg2;
34900 }
34901 return NULL;
34902 }
34903
34904
34905 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34906 PyObject *resultobj = NULL;
34907 wxMenu *arg1 = (wxMenu *) 0 ;
34908 int arg2 ;
34909 wxMenuItem *result;
34910 PyObject * obj0 = 0 ;
34911 PyObject * obj1 = 0 ;
34912 char *kwnames[] = {
34913 (char *) "self",(char *) "id", NULL
34914 };
34915
34916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34918 if (SWIG_arg_fail(1)) SWIG_fail;
34919 {
34920 arg2 = static_cast<int >(SWIG_As_int(obj1));
34921 if (SWIG_arg_fail(2)) SWIG_fail;
34922 }
34923 {
34924 PyThreadState* __tstate = wxPyBeginAllowThreads();
34925 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34926
34927 wxPyEndAllowThreads(__tstate);
34928 if (PyErr_Occurred()) SWIG_fail;
34929 }
34930 {
34931 resultobj = wxPyMake_wxObject(result, 0);
34932 }
34933 return resultobj;
34934 fail:
34935 return NULL;
34936 }
34937
34938
34939 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34940 PyObject *resultobj = NULL;
34941 wxMenu *arg1 = (wxMenu *) 0 ;
34942 size_t arg2 ;
34943 wxMenuItem *result;
34944 PyObject * obj0 = 0 ;
34945 PyObject * obj1 = 0 ;
34946 char *kwnames[] = {
34947 (char *) "self",(char *) "position", NULL
34948 };
34949
34950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34952 if (SWIG_arg_fail(1)) SWIG_fail;
34953 {
34954 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34955 if (SWIG_arg_fail(2)) SWIG_fail;
34956 }
34957 {
34958 PyThreadState* __tstate = wxPyBeginAllowThreads();
34959 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34960
34961 wxPyEndAllowThreads(__tstate);
34962 if (PyErr_Occurred()) SWIG_fail;
34963 }
34964 {
34965 resultobj = wxPyMake_wxObject(result, 0);
34966 }
34967 return resultobj;
34968 fail:
34969 return NULL;
34970 }
34971
34972
34973 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34974 PyObject *resultobj = NULL;
34975 wxMenu *arg1 = (wxMenu *) 0 ;
34976 int arg2 ;
34977 bool arg3 ;
34978 PyObject * obj0 = 0 ;
34979 PyObject * obj1 = 0 ;
34980 PyObject * obj2 = 0 ;
34981 char *kwnames[] = {
34982 (char *) "self",(char *) "id",(char *) "enable", NULL
34983 };
34984
34985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34987 if (SWIG_arg_fail(1)) SWIG_fail;
34988 {
34989 arg2 = static_cast<int >(SWIG_As_int(obj1));
34990 if (SWIG_arg_fail(2)) SWIG_fail;
34991 }
34992 {
34993 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
34994 if (SWIG_arg_fail(3)) SWIG_fail;
34995 }
34996 {
34997 PyThreadState* __tstate = wxPyBeginAllowThreads();
34998 (arg1)->Enable(arg2,arg3);
34999
35000 wxPyEndAllowThreads(__tstate);
35001 if (PyErr_Occurred()) SWIG_fail;
35002 }
35003 Py_INCREF(Py_None); resultobj = Py_None;
35004 return resultobj;
35005 fail:
35006 return NULL;
35007 }
35008
35009
35010 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35011 PyObject *resultobj = NULL;
35012 wxMenu *arg1 = (wxMenu *) 0 ;
35013 int arg2 ;
35014 bool result;
35015 PyObject * obj0 = 0 ;
35016 PyObject * obj1 = 0 ;
35017 char *kwnames[] = {
35018 (char *) "self",(char *) "id", NULL
35019 };
35020
35021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35023 if (SWIG_arg_fail(1)) SWIG_fail;
35024 {
35025 arg2 = static_cast<int >(SWIG_As_int(obj1));
35026 if (SWIG_arg_fail(2)) SWIG_fail;
35027 }
35028 {
35029 PyThreadState* __tstate = wxPyBeginAllowThreads();
35030 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
35031
35032 wxPyEndAllowThreads(__tstate);
35033 if (PyErr_Occurred()) SWIG_fail;
35034 }
35035 {
35036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35037 }
35038 return resultobj;
35039 fail:
35040 return NULL;
35041 }
35042
35043
35044 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35045 PyObject *resultobj = NULL;
35046 wxMenu *arg1 = (wxMenu *) 0 ;
35047 int arg2 ;
35048 bool arg3 ;
35049 PyObject * obj0 = 0 ;
35050 PyObject * obj1 = 0 ;
35051 PyObject * obj2 = 0 ;
35052 char *kwnames[] = {
35053 (char *) "self",(char *) "id",(char *) "check", NULL
35054 };
35055
35056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35058 if (SWIG_arg_fail(1)) SWIG_fail;
35059 {
35060 arg2 = static_cast<int >(SWIG_As_int(obj1));
35061 if (SWIG_arg_fail(2)) SWIG_fail;
35062 }
35063 {
35064 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
35065 if (SWIG_arg_fail(3)) SWIG_fail;
35066 }
35067 {
35068 PyThreadState* __tstate = wxPyBeginAllowThreads();
35069 (arg1)->Check(arg2,arg3);
35070
35071 wxPyEndAllowThreads(__tstate);
35072 if (PyErr_Occurred()) SWIG_fail;
35073 }
35074 Py_INCREF(Py_None); resultobj = Py_None;
35075 return resultobj;
35076 fail:
35077 return NULL;
35078 }
35079
35080
35081 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35082 PyObject *resultobj = NULL;
35083 wxMenu *arg1 = (wxMenu *) 0 ;
35084 int arg2 ;
35085 bool result;
35086 PyObject * obj0 = 0 ;
35087 PyObject * obj1 = 0 ;
35088 char *kwnames[] = {
35089 (char *) "self",(char *) "id", NULL
35090 };
35091
35092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35094 if (SWIG_arg_fail(1)) SWIG_fail;
35095 {
35096 arg2 = static_cast<int >(SWIG_As_int(obj1));
35097 if (SWIG_arg_fail(2)) SWIG_fail;
35098 }
35099 {
35100 PyThreadState* __tstate = wxPyBeginAllowThreads();
35101 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
35102
35103 wxPyEndAllowThreads(__tstate);
35104 if (PyErr_Occurred()) SWIG_fail;
35105 }
35106 {
35107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35108 }
35109 return resultobj;
35110 fail:
35111 return NULL;
35112 }
35113
35114
35115 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35116 PyObject *resultobj = NULL;
35117 wxMenu *arg1 = (wxMenu *) 0 ;
35118 int arg2 ;
35119 wxString *arg3 = 0 ;
35120 bool temp3 = false ;
35121 PyObject * obj0 = 0 ;
35122 PyObject * obj1 = 0 ;
35123 PyObject * obj2 = 0 ;
35124 char *kwnames[] = {
35125 (char *) "self",(char *) "id",(char *) "label", NULL
35126 };
35127
35128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35130 if (SWIG_arg_fail(1)) SWIG_fail;
35131 {
35132 arg2 = static_cast<int >(SWIG_As_int(obj1));
35133 if (SWIG_arg_fail(2)) SWIG_fail;
35134 }
35135 {
35136 arg3 = wxString_in_helper(obj2);
35137 if (arg3 == NULL) SWIG_fail;
35138 temp3 = true;
35139 }
35140 {
35141 PyThreadState* __tstate = wxPyBeginAllowThreads();
35142 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35143
35144 wxPyEndAllowThreads(__tstate);
35145 if (PyErr_Occurred()) SWIG_fail;
35146 }
35147 Py_INCREF(Py_None); resultobj = Py_None;
35148 {
35149 if (temp3)
35150 delete arg3;
35151 }
35152 return resultobj;
35153 fail:
35154 {
35155 if (temp3)
35156 delete arg3;
35157 }
35158 return NULL;
35159 }
35160
35161
35162 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35163 PyObject *resultobj = NULL;
35164 wxMenu *arg1 = (wxMenu *) 0 ;
35165 int arg2 ;
35166 wxString result;
35167 PyObject * obj0 = 0 ;
35168 PyObject * obj1 = 0 ;
35169 char *kwnames[] = {
35170 (char *) "self",(char *) "id", NULL
35171 };
35172
35173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35175 if (SWIG_arg_fail(1)) SWIG_fail;
35176 {
35177 arg2 = static_cast<int >(SWIG_As_int(obj1));
35178 if (SWIG_arg_fail(2)) SWIG_fail;
35179 }
35180 {
35181 PyThreadState* __tstate = wxPyBeginAllowThreads();
35182 result = ((wxMenu const *)arg1)->GetLabel(arg2);
35183
35184 wxPyEndAllowThreads(__tstate);
35185 if (PyErr_Occurred()) SWIG_fail;
35186 }
35187 {
35188 #if wxUSE_UNICODE
35189 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35190 #else
35191 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35192 #endif
35193 }
35194 return resultobj;
35195 fail:
35196 return NULL;
35197 }
35198
35199
35200 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35201 PyObject *resultobj = NULL;
35202 wxMenu *arg1 = (wxMenu *) 0 ;
35203 int arg2 ;
35204 wxString *arg3 = 0 ;
35205 bool temp3 = false ;
35206 PyObject * obj0 = 0 ;
35207 PyObject * obj1 = 0 ;
35208 PyObject * obj2 = 0 ;
35209 char *kwnames[] = {
35210 (char *) "self",(char *) "id",(char *) "helpString", NULL
35211 };
35212
35213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35215 if (SWIG_arg_fail(1)) SWIG_fail;
35216 {
35217 arg2 = static_cast<int >(SWIG_As_int(obj1));
35218 if (SWIG_arg_fail(2)) SWIG_fail;
35219 }
35220 {
35221 arg3 = wxString_in_helper(obj2);
35222 if (arg3 == NULL) SWIG_fail;
35223 temp3 = true;
35224 }
35225 {
35226 PyThreadState* __tstate = wxPyBeginAllowThreads();
35227 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35228
35229 wxPyEndAllowThreads(__tstate);
35230 if (PyErr_Occurred()) SWIG_fail;
35231 }
35232 Py_INCREF(Py_None); resultobj = Py_None;
35233 {
35234 if (temp3)
35235 delete arg3;
35236 }
35237 return resultobj;
35238 fail:
35239 {
35240 if (temp3)
35241 delete arg3;
35242 }
35243 return NULL;
35244 }
35245
35246
35247 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35248 PyObject *resultobj = NULL;
35249 wxMenu *arg1 = (wxMenu *) 0 ;
35250 int arg2 ;
35251 wxString result;
35252 PyObject * obj0 = 0 ;
35253 PyObject * obj1 = 0 ;
35254 char *kwnames[] = {
35255 (char *) "self",(char *) "id", NULL
35256 };
35257
35258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35260 if (SWIG_arg_fail(1)) SWIG_fail;
35261 {
35262 arg2 = static_cast<int >(SWIG_As_int(obj1));
35263 if (SWIG_arg_fail(2)) SWIG_fail;
35264 }
35265 {
35266 PyThreadState* __tstate = wxPyBeginAllowThreads();
35267 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
35268
35269 wxPyEndAllowThreads(__tstate);
35270 if (PyErr_Occurred()) SWIG_fail;
35271 }
35272 {
35273 #if wxUSE_UNICODE
35274 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35275 #else
35276 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35277 #endif
35278 }
35279 return resultobj;
35280 fail:
35281 return NULL;
35282 }
35283
35284
35285 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35286 PyObject *resultobj = NULL;
35287 wxMenu *arg1 = (wxMenu *) 0 ;
35288 wxString *arg2 = 0 ;
35289 bool temp2 = false ;
35290 PyObject * obj0 = 0 ;
35291 PyObject * obj1 = 0 ;
35292 char *kwnames[] = {
35293 (char *) "self",(char *) "title", NULL
35294 };
35295
35296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
35297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35298 if (SWIG_arg_fail(1)) SWIG_fail;
35299 {
35300 arg2 = wxString_in_helper(obj1);
35301 if (arg2 == NULL) SWIG_fail;
35302 temp2 = true;
35303 }
35304 {
35305 PyThreadState* __tstate = wxPyBeginAllowThreads();
35306 (arg1)->SetTitle((wxString const &)*arg2);
35307
35308 wxPyEndAllowThreads(__tstate);
35309 if (PyErr_Occurred()) SWIG_fail;
35310 }
35311 Py_INCREF(Py_None); resultobj = Py_None;
35312 {
35313 if (temp2)
35314 delete arg2;
35315 }
35316 return resultobj;
35317 fail:
35318 {
35319 if (temp2)
35320 delete arg2;
35321 }
35322 return NULL;
35323 }
35324
35325
35326 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35327 PyObject *resultobj = NULL;
35328 wxMenu *arg1 = (wxMenu *) 0 ;
35329 wxString result;
35330 PyObject * obj0 = 0 ;
35331 char *kwnames[] = {
35332 (char *) "self", NULL
35333 };
35334
35335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
35336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35337 if (SWIG_arg_fail(1)) SWIG_fail;
35338 {
35339 PyThreadState* __tstate = wxPyBeginAllowThreads();
35340 result = ((wxMenu const *)arg1)->GetTitle();
35341
35342 wxPyEndAllowThreads(__tstate);
35343 if (PyErr_Occurred()) SWIG_fail;
35344 }
35345 {
35346 #if wxUSE_UNICODE
35347 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35348 #else
35349 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35350 #endif
35351 }
35352 return resultobj;
35353 fail:
35354 return NULL;
35355 }
35356
35357
35358 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35359 PyObject *resultobj = NULL;
35360 wxMenu *arg1 = (wxMenu *) 0 ;
35361 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
35362 PyObject * obj0 = 0 ;
35363 PyObject * obj1 = 0 ;
35364 char *kwnames[] = {
35365 (char *) "self",(char *) "handler", NULL
35366 };
35367
35368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
35369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35370 if (SWIG_arg_fail(1)) SWIG_fail;
35371 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35372 if (SWIG_arg_fail(2)) SWIG_fail;
35373 {
35374 PyThreadState* __tstate = wxPyBeginAllowThreads();
35375 (arg1)->SetEventHandler(arg2);
35376
35377 wxPyEndAllowThreads(__tstate);
35378 if (PyErr_Occurred()) SWIG_fail;
35379 }
35380 Py_INCREF(Py_None); resultobj = Py_None;
35381 return resultobj;
35382 fail:
35383 return NULL;
35384 }
35385
35386
35387 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35388 PyObject *resultobj = NULL;
35389 wxMenu *arg1 = (wxMenu *) 0 ;
35390 wxEvtHandler *result;
35391 PyObject * obj0 = 0 ;
35392 char *kwnames[] = {
35393 (char *) "self", NULL
35394 };
35395
35396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
35397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35398 if (SWIG_arg_fail(1)) SWIG_fail;
35399 {
35400 PyThreadState* __tstate = wxPyBeginAllowThreads();
35401 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
35402
35403 wxPyEndAllowThreads(__tstate);
35404 if (PyErr_Occurred()) SWIG_fail;
35405 }
35406 {
35407 resultobj = wxPyMake_wxObject(result, 0);
35408 }
35409 return resultobj;
35410 fail:
35411 return NULL;
35412 }
35413
35414
35415 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35416 PyObject *resultobj = NULL;
35417 wxMenu *arg1 = (wxMenu *) 0 ;
35418 wxWindow *arg2 = (wxWindow *) 0 ;
35419 PyObject * obj0 = 0 ;
35420 PyObject * obj1 = 0 ;
35421 char *kwnames[] = {
35422 (char *) "self",(char *) "win", NULL
35423 };
35424
35425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
35426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35427 if (SWIG_arg_fail(1)) SWIG_fail;
35428 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
35429 if (SWIG_arg_fail(2)) SWIG_fail;
35430 {
35431 PyThreadState* __tstate = wxPyBeginAllowThreads();
35432 (arg1)->SetInvokingWindow(arg2);
35433
35434 wxPyEndAllowThreads(__tstate);
35435 if (PyErr_Occurred()) SWIG_fail;
35436 }
35437 Py_INCREF(Py_None); resultobj = Py_None;
35438 return resultobj;
35439 fail:
35440 return NULL;
35441 }
35442
35443
35444 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35445 PyObject *resultobj = NULL;
35446 wxMenu *arg1 = (wxMenu *) 0 ;
35447 wxWindow *result;
35448 PyObject * obj0 = 0 ;
35449 char *kwnames[] = {
35450 (char *) "self", NULL
35451 };
35452
35453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
35454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35455 if (SWIG_arg_fail(1)) SWIG_fail;
35456 {
35457 PyThreadState* __tstate = wxPyBeginAllowThreads();
35458 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
35459
35460 wxPyEndAllowThreads(__tstate);
35461 if (PyErr_Occurred()) SWIG_fail;
35462 }
35463 {
35464 resultobj = wxPyMake_wxObject(result, 0);
35465 }
35466 return resultobj;
35467 fail:
35468 return NULL;
35469 }
35470
35471
35472 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
35473 PyObject *resultobj = NULL;
35474 wxMenu *arg1 = (wxMenu *) 0 ;
35475 long result;
35476 PyObject * obj0 = 0 ;
35477 char *kwnames[] = {
35478 (char *) "self", NULL
35479 };
35480
35481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
35482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35483 if (SWIG_arg_fail(1)) SWIG_fail;
35484 {
35485 PyThreadState* __tstate = wxPyBeginAllowThreads();
35486 result = (long)((wxMenu const *)arg1)->GetStyle();
35487
35488 wxPyEndAllowThreads(__tstate);
35489 if (PyErr_Occurred()) SWIG_fail;
35490 }
35491 {
35492 resultobj = SWIG_From_long(static_cast<long >(result));
35493 }
35494 return resultobj;
35495 fail:
35496 return NULL;
35497 }
35498
35499
35500 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
35501 PyObject *resultobj = NULL;
35502 wxMenu *arg1 = (wxMenu *) 0 ;
35503 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
35504 PyObject * obj0 = 0 ;
35505 PyObject * obj1 = 0 ;
35506 char *kwnames[] = {
35507 (char *) "self",(char *) "source", NULL
35508 };
35509
35510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
35511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35512 if (SWIG_arg_fail(1)) SWIG_fail;
35513 if (obj1) {
35514 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35515 if (SWIG_arg_fail(2)) SWIG_fail;
35516 }
35517 {
35518 PyThreadState* __tstate = wxPyBeginAllowThreads();
35519 (arg1)->UpdateUI(arg2);
35520
35521 wxPyEndAllowThreads(__tstate);
35522 if (PyErr_Occurred()) SWIG_fail;
35523 }
35524 Py_INCREF(Py_None); resultobj = Py_None;
35525 return resultobj;
35526 fail:
35527 return NULL;
35528 }
35529
35530
35531 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35532 PyObject *resultobj = NULL;
35533 wxMenu *arg1 = (wxMenu *) 0 ;
35534 wxMenuBar *result;
35535 PyObject * obj0 = 0 ;
35536 char *kwnames[] = {
35537 (char *) "self", NULL
35538 };
35539
35540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
35541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35542 if (SWIG_arg_fail(1)) SWIG_fail;
35543 {
35544 PyThreadState* __tstate = wxPyBeginAllowThreads();
35545 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
35546
35547 wxPyEndAllowThreads(__tstate);
35548 if (PyErr_Occurred()) SWIG_fail;
35549 }
35550 {
35551 resultobj = wxPyMake_wxObject(result, 0);
35552 }
35553 return resultobj;
35554 fail:
35555 return NULL;
35556 }
35557
35558
35559 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35560 PyObject *resultobj = NULL;
35561 wxMenu *arg1 = (wxMenu *) 0 ;
35562 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
35563 PyObject * obj0 = 0 ;
35564 PyObject * obj1 = 0 ;
35565 char *kwnames[] = {
35566 (char *) "self",(char *) "menubar", NULL
35567 };
35568
35569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
35570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35571 if (SWIG_arg_fail(1)) SWIG_fail;
35572 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
35573 if (SWIG_arg_fail(2)) SWIG_fail;
35574 {
35575 PyThreadState* __tstate = wxPyBeginAllowThreads();
35576 (arg1)->Attach(arg2);
35577
35578 wxPyEndAllowThreads(__tstate);
35579 if (PyErr_Occurred()) SWIG_fail;
35580 }
35581 Py_INCREF(Py_None); resultobj = Py_None;
35582 return resultobj;
35583 fail:
35584 return NULL;
35585 }
35586
35587
35588 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35589 PyObject *resultobj = NULL;
35590 wxMenu *arg1 = (wxMenu *) 0 ;
35591 PyObject * obj0 = 0 ;
35592 char *kwnames[] = {
35593 (char *) "self", NULL
35594 };
35595
35596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
35597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35598 if (SWIG_arg_fail(1)) SWIG_fail;
35599 {
35600 PyThreadState* __tstate = wxPyBeginAllowThreads();
35601 (arg1)->Detach();
35602
35603 wxPyEndAllowThreads(__tstate);
35604 if (PyErr_Occurred()) SWIG_fail;
35605 }
35606 Py_INCREF(Py_None); resultobj = Py_None;
35607 return resultobj;
35608 fail:
35609 return NULL;
35610 }
35611
35612
35613 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35614 PyObject *resultobj = NULL;
35615 wxMenu *arg1 = (wxMenu *) 0 ;
35616 bool result;
35617 PyObject * obj0 = 0 ;
35618 char *kwnames[] = {
35619 (char *) "self", NULL
35620 };
35621
35622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
35623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35624 if (SWIG_arg_fail(1)) SWIG_fail;
35625 {
35626 PyThreadState* __tstate = wxPyBeginAllowThreads();
35627 result = (bool)((wxMenu const *)arg1)->IsAttached();
35628
35629 wxPyEndAllowThreads(__tstate);
35630 if (PyErr_Occurred()) SWIG_fail;
35631 }
35632 {
35633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35634 }
35635 return resultobj;
35636 fail:
35637 return NULL;
35638 }
35639
35640
35641 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35642 PyObject *resultobj = NULL;
35643 wxMenu *arg1 = (wxMenu *) 0 ;
35644 wxMenu *arg2 = (wxMenu *) 0 ;
35645 PyObject * obj0 = 0 ;
35646 PyObject * obj1 = 0 ;
35647 char *kwnames[] = {
35648 (char *) "self",(char *) "parent", NULL
35649 };
35650
35651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
35652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35653 if (SWIG_arg_fail(1)) SWIG_fail;
35654 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35655 if (SWIG_arg_fail(2)) SWIG_fail;
35656 {
35657 PyThreadState* __tstate = wxPyBeginAllowThreads();
35658 (arg1)->SetParent(arg2);
35659
35660 wxPyEndAllowThreads(__tstate);
35661 if (PyErr_Occurred()) SWIG_fail;
35662 }
35663 Py_INCREF(Py_None); resultobj = Py_None;
35664 return resultobj;
35665 fail:
35666 return NULL;
35667 }
35668
35669
35670 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35671 PyObject *resultobj = NULL;
35672 wxMenu *arg1 = (wxMenu *) 0 ;
35673 wxMenu *result;
35674 PyObject * obj0 = 0 ;
35675 char *kwnames[] = {
35676 (char *) "self", NULL
35677 };
35678
35679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
35680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35681 if (SWIG_arg_fail(1)) SWIG_fail;
35682 {
35683 PyThreadState* __tstate = wxPyBeginAllowThreads();
35684 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
35685
35686 wxPyEndAllowThreads(__tstate);
35687 if (PyErr_Occurred()) SWIG_fail;
35688 }
35689 {
35690 resultobj = wxPyMake_wxObject(result, 0);
35691 }
35692 return resultobj;
35693 fail:
35694 return NULL;
35695 }
35696
35697
35698 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
35699 PyObject *obj;
35700 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35701 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
35702 Py_INCREF(obj);
35703 return Py_BuildValue((char *)"");
35704 }
35705 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35706 PyObject *resultobj = NULL;
35707 long arg1 = (long) 0 ;
35708 wxMenuBar *result;
35709 PyObject * obj0 = 0 ;
35710 char *kwnames[] = {
35711 (char *) "style", NULL
35712 };
35713
35714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
35715 if (obj0) {
35716 {
35717 arg1 = static_cast<long >(SWIG_As_long(obj0));
35718 if (SWIG_arg_fail(1)) SWIG_fail;
35719 }
35720 }
35721 {
35722 if (!wxPyCheckForApp()) SWIG_fail;
35723 PyThreadState* __tstate = wxPyBeginAllowThreads();
35724 result = (wxMenuBar *)new wxMenuBar(arg1);
35725
35726 wxPyEndAllowThreads(__tstate);
35727 if (PyErr_Occurred()) SWIG_fail;
35728 }
35729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
35730 return resultobj;
35731 fail:
35732 return NULL;
35733 }
35734
35735
35736 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
35737 PyObject *resultobj = NULL;
35738 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35739 wxMenu *arg2 = (wxMenu *) 0 ;
35740 wxString *arg3 = 0 ;
35741 bool result;
35742 bool temp3 = false ;
35743 PyObject * obj0 = 0 ;
35744 PyObject * obj1 = 0 ;
35745 PyObject * obj2 = 0 ;
35746 char *kwnames[] = {
35747 (char *) "self",(char *) "menu",(char *) "title", NULL
35748 };
35749
35750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
35751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35752 if (SWIG_arg_fail(1)) SWIG_fail;
35753 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35754 if (SWIG_arg_fail(2)) SWIG_fail;
35755 {
35756 arg3 = wxString_in_helper(obj2);
35757 if (arg3 == NULL) SWIG_fail;
35758 temp3 = true;
35759 }
35760 {
35761 PyThreadState* __tstate = wxPyBeginAllowThreads();
35762 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
35763
35764 wxPyEndAllowThreads(__tstate);
35765 if (PyErr_Occurred()) SWIG_fail;
35766 }
35767 {
35768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35769 }
35770 {
35771 if (temp3)
35772 delete arg3;
35773 }
35774 return resultobj;
35775 fail:
35776 {
35777 if (temp3)
35778 delete arg3;
35779 }
35780 return NULL;
35781 }
35782
35783
35784 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35785 PyObject *resultobj = NULL;
35786 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35787 size_t arg2 ;
35788 wxMenu *arg3 = (wxMenu *) 0 ;
35789 wxString *arg4 = 0 ;
35790 bool result;
35791 bool temp4 = false ;
35792 PyObject * obj0 = 0 ;
35793 PyObject * obj1 = 0 ;
35794 PyObject * obj2 = 0 ;
35795 PyObject * obj3 = 0 ;
35796 char *kwnames[] = {
35797 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35798 };
35799
35800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35802 if (SWIG_arg_fail(1)) SWIG_fail;
35803 {
35804 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35805 if (SWIG_arg_fail(2)) SWIG_fail;
35806 }
35807 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35808 if (SWIG_arg_fail(3)) SWIG_fail;
35809 {
35810 arg4 = wxString_in_helper(obj3);
35811 if (arg4 == NULL) SWIG_fail;
35812 temp4 = true;
35813 }
35814 {
35815 PyThreadState* __tstate = wxPyBeginAllowThreads();
35816 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35817
35818 wxPyEndAllowThreads(__tstate);
35819 if (PyErr_Occurred()) SWIG_fail;
35820 }
35821 {
35822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35823 }
35824 {
35825 if (temp4)
35826 delete arg4;
35827 }
35828 return resultobj;
35829 fail:
35830 {
35831 if (temp4)
35832 delete arg4;
35833 }
35834 return NULL;
35835 }
35836
35837
35838 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35839 PyObject *resultobj = NULL;
35840 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35841 size_t result;
35842 PyObject * obj0 = 0 ;
35843 char *kwnames[] = {
35844 (char *) "self", NULL
35845 };
35846
35847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35849 if (SWIG_arg_fail(1)) SWIG_fail;
35850 {
35851 PyThreadState* __tstate = wxPyBeginAllowThreads();
35852 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35853
35854 wxPyEndAllowThreads(__tstate);
35855 if (PyErr_Occurred()) SWIG_fail;
35856 }
35857 {
35858 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
35859 }
35860 return resultobj;
35861 fail:
35862 return NULL;
35863 }
35864
35865
35866 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35867 PyObject *resultobj = NULL;
35868 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35869 size_t arg2 ;
35870 wxMenu *result;
35871 PyObject * obj0 = 0 ;
35872 PyObject * obj1 = 0 ;
35873 char *kwnames[] = {
35874 (char *) "self",(char *) "pos", NULL
35875 };
35876
35877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35879 if (SWIG_arg_fail(1)) SWIG_fail;
35880 {
35881 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35882 if (SWIG_arg_fail(2)) SWIG_fail;
35883 }
35884 {
35885 PyThreadState* __tstate = wxPyBeginAllowThreads();
35886 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35887
35888 wxPyEndAllowThreads(__tstate);
35889 if (PyErr_Occurred()) SWIG_fail;
35890 }
35891 {
35892 resultobj = wxPyMake_wxObject(result, 0);
35893 }
35894 return resultobj;
35895 fail:
35896 return NULL;
35897 }
35898
35899
35900 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35901 PyObject *resultobj = NULL;
35902 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35903 size_t arg2 ;
35904 wxMenu *arg3 = (wxMenu *) 0 ;
35905 wxString *arg4 = 0 ;
35906 wxMenu *result;
35907 bool temp4 = false ;
35908 PyObject * obj0 = 0 ;
35909 PyObject * obj1 = 0 ;
35910 PyObject * obj2 = 0 ;
35911 PyObject * obj3 = 0 ;
35912 char *kwnames[] = {
35913 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35914 };
35915
35916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35918 if (SWIG_arg_fail(1)) SWIG_fail;
35919 {
35920 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35921 if (SWIG_arg_fail(2)) SWIG_fail;
35922 }
35923 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35924 if (SWIG_arg_fail(3)) SWIG_fail;
35925 {
35926 arg4 = wxString_in_helper(obj3);
35927 if (arg4 == NULL) SWIG_fail;
35928 temp4 = true;
35929 }
35930 {
35931 PyThreadState* __tstate = wxPyBeginAllowThreads();
35932 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35933
35934 wxPyEndAllowThreads(__tstate);
35935 if (PyErr_Occurred()) SWIG_fail;
35936 }
35937 {
35938 resultobj = wxPyMake_wxObject(result, 0);
35939 }
35940 {
35941 if (temp4)
35942 delete arg4;
35943 }
35944 return resultobj;
35945 fail:
35946 {
35947 if (temp4)
35948 delete arg4;
35949 }
35950 return NULL;
35951 }
35952
35953
35954 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35955 PyObject *resultobj = NULL;
35956 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35957 size_t arg2 ;
35958 wxMenu *result;
35959 PyObject * obj0 = 0 ;
35960 PyObject * obj1 = 0 ;
35961 char *kwnames[] = {
35962 (char *) "self",(char *) "pos", NULL
35963 };
35964
35965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35967 if (SWIG_arg_fail(1)) SWIG_fail;
35968 {
35969 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35970 if (SWIG_arg_fail(2)) SWIG_fail;
35971 }
35972 {
35973 PyThreadState* __tstate = wxPyBeginAllowThreads();
35974 result = (wxMenu *)(arg1)->Remove(arg2);
35975
35976 wxPyEndAllowThreads(__tstate);
35977 if (PyErr_Occurred()) SWIG_fail;
35978 }
35979 {
35980 resultobj = wxPyMake_wxObject(result, 0);
35981 }
35982 return resultobj;
35983 fail:
35984 return NULL;
35985 }
35986
35987
35988 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35989 PyObject *resultobj = NULL;
35990 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35991 size_t arg2 ;
35992 bool arg3 ;
35993 PyObject * obj0 = 0 ;
35994 PyObject * obj1 = 0 ;
35995 PyObject * obj2 = 0 ;
35996 char *kwnames[] = {
35997 (char *) "self",(char *) "pos",(char *) "enable", NULL
35998 };
35999
36000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
36001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36002 if (SWIG_arg_fail(1)) SWIG_fail;
36003 {
36004 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36005 if (SWIG_arg_fail(2)) SWIG_fail;
36006 }
36007 {
36008 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36009 if (SWIG_arg_fail(3)) SWIG_fail;
36010 }
36011 {
36012 PyThreadState* __tstate = wxPyBeginAllowThreads();
36013 (arg1)->EnableTop(arg2,arg3);
36014
36015 wxPyEndAllowThreads(__tstate);
36016 if (PyErr_Occurred()) SWIG_fail;
36017 }
36018 Py_INCREF(Py_None); resultobj = Py_None;
36019 return resultobj;
36020 fail:
36021 return NULL;
36022 }
36023
36024
36025 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
36026 PyObject *resultobj = NULL;
36027 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36028 size_t arg2 ;
36029 bool result;
36030 PyObject * obj0 = 0 ;
36031 PyObject * obj1 = 0 ;
36032 char *kwnames[] = {
36033 (char *) "self",(char *) "pos", NULL
36034 };
36035
36036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
36037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36038 if (SWIG_arg_fail(1)) SWIG_fail;
36039 {
36040 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36041 if (SWIG_arg_fail(2)) SWIG_fail;
36042 }
36043 {
36044 PyThreadState* __tstate = wxPyBeginAllowThreads();
36045 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
36046
36047 wxPyEndAllowThreads(__tstate);
36048 if (PyErr_Occurred()) SWIG_fail;
36049 }
36050 {
36051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36052 }
36053 return resultobj;
36054 fail:
36055 return NULL;
36056 }
36057
36058
36059 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
36060 PyObject *resultobj = NULL;
36061 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36062 size_t arg2 ;
36063 wxString *arg3 = 0 ;
36064 bool temp3 = false ;
36065 PyObject * obj0 = 0 ;
36066 PyObject * obj1 = 0 ;
36067 PyObject * obj2 = 0 ;
36068 char *kwnames[] = {
36069 (char *) "self",(char *) "pos",(char *) "label", NULL
36070 };
36071
36072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
36073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36074 if (SWIG_arg_fail(1)) SWIG_fail;
36075 {
36076 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36077 if (SWIG_arg_fail(2)) SWIG_fail;
36078 }
36079 {
36080 arg3 = wxString_in_helper(obj2);
36081 if (arg3 == NULL) SWIG_fail;
36082 temp3 = true;
36083 }
36084 {
36085 PyThreadState* __tstate = wxPyBeginAllowThreads();
36086 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
36087
36088 wxPyEndAllowThreads(__tstate);
36089 if (PyErr_Occurred()) SWIG_fail;
36090 }
36091 Py_INCREF(Py_None); resultobj = Py_None;
36092 {
36093 if (temp3)
36094 delete arg3;
36095 }
36096 return resultobj;
36097 fail:
36098 {
36099 if (temp3)
36100 delete arg3;
36101 }
36102 return NULL;
36103 }
36104
36105
36106 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
36107 PyObject *resultobj = NULL;
36108 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36109 size_t arg2 ;
36110 wxString result;
36111 PyObject * obj0 = 0 ;
36112 PyObject * obj1 = 0 ;
36113 char *kwnames[] = {
36114 (char *) "self",(char *) "pos", NULL
36115 };
36116
36117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
36118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36119 if (SWIG_arg_fail(1)) SWIG_fail;
36120 {
36121 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36122 if (SWIG_arg_fail(2)) SWIG_fail;
36123 }
36124 {
36125 PyThreadState* __tstate = wxPyBeginAllowThreads();
36126 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
36127
36128 wxPyEndAllowThreads(__tstate);
36129 if (PyErr_Occurred()) SWIG_fail;
36130 }
36131 {
36132 #if wxUSE_UNICODE
36133 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36134 #else
36135 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36136 #endif
36137 }
36138 return resultobj;
36139 fail:
36140 return NULL;
36141 }
36142
36143
36144 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36145 PyObject *resultobj = NULL;
36146 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36147 wxString *arg2 = 0 ;
36148 wxString *arg3 = 0 ;
36149 int result;
36150 bool temp2 = false ;
36151 bool temp3 = false ;
36152 PyObject * obj0 = 0 ;
36153 PyObject * obj1 = 0 ;
36154 PyObject * obj2 = 0 ;
36155 char *kwnames[] = {
36156 (char *) "self",(char *) "menu",(char *) "item", NULL
36157 };
36158
36159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
36160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36161 if (SWIG_arg_fail(1)) SWIG_fail;
36162 {
36163 arg2 = wxString_in_helper(obj1);
36164 if (arg2 == NULL) SWIG_fail;
36165 temp2 = true;
36166 }
36167 {
36168 arg3 = wxString_in_helper(obj2);
36169 if (arg3 == NULL) SWIG_fail;
36170 temp3 = true;
36171 }
36172 {
36173 PyThreadState* __tstate = wxPyBeginAllowThreads();
36174 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
36175
36176 wxPyEndAllowThreads(__tstate);
36177 if (PyErr_Occurred()) SWIG_fail;
36178 }
36179 {
36180 resultobj = SWIG_From_int(static_cast<int >(result));
36181 }
36182 {
36183 if (temp2)
36184 delete arg2;
36185 }
36186 {
36187 if (temp3)
36188 delete arg3;
36189 }
36190 return resultobj;
36191 fail:
36192 {
36193 if (temp2)
36194 delete arg2;
36195 }
36196 {
36197 if (temp3)
36198 delete arg3;
36199 }
36200 return NULL;
36201 }
36202
36203
36204 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
36205 PyObject *resultobj = NULL;
36206 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36207 int arg2 ;
36208 wxMenuItem *result;
36209 PyObject * obj0 = 0 ;
36210 PyObject * obj1 = 0 ;
36211 char *kwnames[] = {
36212 (char *) "self",(char *) "id", NULL
36213 };
36214
36215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
36216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36217 if (SWIG_arg_fail(1)) SWIG_fail;
36218 {
36219 arg2 = static_cast<int >(SWIG_As_int(obj1));
36220 if (SWIG_arg_fail(2)) SWIG_fail;
36221 }
36222 {
36223 PyThreadState* __tstate = wxPyBeginAllowThreads();
36224 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
36225
36226 wxPyEndAllowThreads(__tstate);
36227 if (PyErr_Occurred()) SWIG_fail;
36228 }
36229 {
36230 resultobj = wxPyMake_wxObject(result, 0);
36231 }
36232 return resultobj;
36233 fail:
36234 return NULL;
36235 }
36236
36237
36238 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36239 PyObject *resultobj = NULL;
36240 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36241 wxString *arg2 = 0 ;
36242 int result;
36243 bool temp2 = false ;
36244 PyObject * obj0 = 0 ;
36245 PyObject * obj1 = 0 ;
36246 char *kwnames[] = {
36247 (char *) "self",(char *) "title", NULL
36248 };
36249
36250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
36251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36252 if (SWIG_arg_fail(1)) SWIG_fail;
36253 {
36254 arg2 = wxString_in_helper(obj1);
36255 if (arg2 == NULL) SWIG_fail;
36256 temp2 = true;
36257 }
36258 {
36259 PyThreadState* __tstate = wxPyBeginAllowThreads();
36260 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
36261
36262 wxPyEndAllowThreads(__tstate);
36263 if (PyErr_Occurred()) SWIG_fail;
36264 }
36265 {
36266 resultobj = SWIG_From_int(static_cast<int >(result));
36267 }
36268 {
36269 if (temp2)
36270 delete arg2;
36271 }
36272 return resultobj;
36273 fail:
36274 {
36275 if (temp2)
36276 delete arg2;
36277 }
36278 return NULL;
36279 }
36280
36281
36282 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36283 PyObject *resultobj = NULL;
36284 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36285 int arg2 ;
36286 bool arg3 ;
36287 PyObject * obj0 = 0 ;
36288 PyObject * obj1 = 0 ;
36289 PyObject * obj2 = 0 ;
36290 char *kwnames[] = {
36291 (char *) "self",(char *) "id",(char *) "enable", NULL
36292 };
36293
36294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
36295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36296 if (SWIG_arg_fail(1)) SWIG_fail;
36297 {
36298 arg2 = static_cast<int >(SWIG_As_int(obj1));
36299 if (SWIG_arg_fail(2)) SWIG_fail;
36300 }
36301 {
36302 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36303 if (SWIG_arg_fail(3)) SWIG_fail;
36304 }
36305 {
36306 PyThreadState* __tstate = wxPyBeginAllowThreads();
36307 (arg1)->Enable(arg2,arg3);
36308
36309 wxPyEndAllowThreads(__tstate);
36310 if (PyErr_Occurred()) SWIG_fail;
36311 }
36312 Py_INCREF(Py_None); resultobj = Py_None;
36313 return resultobj;
36314 fail:
36315 return NULL;
36316 }
36317
36318
36319 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36320 PyObject *resultobj = NULL;
36321 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36322 int arg2 ;
36323 bool arg3 ;
36324 PyObject * obj0 = 0 ;
36325 PyObject * obj1 = 0 ;
36326 PyObject * obj2 = 0 ;
36327 char *kwnames[] = {
36328 (char *) "self",(char *) "id",(char *) "check", NULL
36329 };
36330
36331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
36332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36333 if (SWIG_arg_fail(1)) SWIG_fail;
36334 {
36335 arg2 = static_cast<int >(SWIG_As_int(obj1));
36336 if (SWIG_arg_fail(2)) SWIG_fail;
36337 }
36338 {
36339 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36340 if (SWIG_arg_fail(3)) SWIG_fail;
36341 }
36342 {
36343 PyThreadState* __tstate = wxPyBeginAllowThreads();
36344 (arg1)->Check(arg2,arg3);
36345
36346 wxPyEndAllowThreads(__tstate);
36347 if (PyErr_Occurred()) SWIG_fail;
36348 }
36349 Py_INCREF(Py_None); resultobj = Py_None;
36350 return resultobj;
36351 fail:
36352 return NULL;
36353 }
36354
36355
36356 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36357 PyObject *resultobj = NULL;
36358 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36359 int arg2 ;
36360 bool result;
36361 PyObject * obj0 = 0 ;
36362 PyObject * obj1 = 0 ;
36363 char *kwnames[] = {
36364 (char *) "self",(char *) "id", NULL
36365 };
36366
36367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
36368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36369 if (SWIG_arg_fail(1)) SWIG_fail;
36370 {
36371 arg2 = static_cast<int >(SWIG_As_int(obj1));
36372 if (SWIG_arg_fail(2)) SWIG_fail;
36373 }
36374 {
36375 PyThreadState* __tstate = wxPyBeginAllowThreads();
36376 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
36377
36378 wxPyEndAllowThreads(__tstate);
36379 if (PyErr_Occurred()) SWIG_fail;
36380 }
36381 {
36382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36383 }
36384 return resultobj;
36385 fail:
36386 return NULL;
36387 }
36388
36389
36390 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36391 PyObject *resultobj = NULL;
36392 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36393 int arg2 ;
36394 bool result;
36395 PyObject * obj0 = 0 ;
36396 PyObject * obj1 = 0 ;
36397 char *kwnames[] = {
36398 (char *) "self",(char *) "id", NULL
36399 };
36400
36401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
36402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36403 if (SWIG_arg_fail(1)) SWIG_fail;
36404 {
36405 arg2 = static_cast<int >(SWIG_As_int(obj1));
36406 if (SWIG_arg_fail(2)) SWIG_fail;
36407 }
36408 {
36409 PyThreadState* __tstate = wxPyBeginAllowThreads();
36410 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
36411
36412 wxPyEndAllowThreads(__tstate);
36413 if (PyErr_Occurred()) SWIG_fail;
36414 }
36415 {
36416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36417 }
36418 return resultobj;
36419 fail:
36420 return NULL;
36421 }
36422
36423
36424 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36425 PyObject *resultobj = NULL;
36426 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36427 int arg2 ;
36428 wxString *arg3 = 0 ;
36429 bool temp3 = false ;
36430 PyObject * obj0 = 0 ;
36431 PyObject * obj1 = 0 ;
36432 PyObject * obj2 = 0 ;
36433 char *kwnames[] = {
36434 (char *) "self",(char *) "id",(char *) "label", NULL
36435 };
36436
36437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
36438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36439 if (SWIG_arg_fail(1)) SWIG_fail;
36440 {
36441 arg2 = static_cast<int >(SWIG_As_int(obj1));
36442 if (SWIG_arg_fail(2)) SWIG_fail;
36443 }
36444 {
36445 arg3 = wxString_in_helper(obj2);
36446 if (arg3 == NULL) SWIG_fail;
36447 temp3 = true;
36448 }
36449 {
36450 PyThreadState* __tstate = wxPyBeginAllowThreads();
36451 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
36452
36453 wxPyEndAllowThreads(__tstate);
36454 if (PyErr_Occurred()) SWIG_fail;
36455 }
36456 Py_INCREF(Py_None); resultobj = Py_None;
36457 {
36458 if (temp3)
36459 delete arg3;
36460 }
36461 return resultobj;
36462 fail:
36463 {
36464 if (temp3)
36465 delete arg3;
36466 }
36467 return NULL;
36468 }
36469
36470
36471 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36472 PyObject *resultobj = NULL;
36473 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36474 int arg2 ;
36475 wxString result;
36476 PyObject * obj0 = 0 ;
36477 PyObject * obj1 = 0 ;
36478 char *kwnames[] = {
36479 (char *) "self",(char *) "id", NULL
36480 };
36481
36482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
36483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36484 if (SWIG_arg_fail(1)) SWIG_fail;
36485 {
36486 arg2 = static_cast<int >(SWIG_As_int(obj1));
36487 if (SWIG_arg_fail(2)) SWIG_fail;
36488 }
36489 {
36490 PyThreadState* __tstate = wxPyBeginAllowThreads();
36491 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
36492
36493 wxPyEndAllowThreads(__tstate);
36494 if (PyErr_Occurred()) SWIG_fail;
36495 }
36496 {
36497 #if wxUSE_UNICODE
36498 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36499 #else
36500 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36501 #endif
36502 }
36503 return resultobj;
36504 fail:
36505 return NULL;
36506 }
36507
36508
36509 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36510 PyObject *resultobj = NULL;
36511 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36512 int arg2 ;
36513 wxString *arg3 = 0 ;
36514 bool temp3 = false ;
36515 PyObject * obj0 = 0 ;
36516 PyObject * obj1 = 0 ;
36517 PyObject * obj2 = 0 ;
36518 char *kwnames[] = {
36519 (char *) "self",(char *) "id",(char *) "helpString", NULL
36520 };
36521
36522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36524 if (SWIG_arg_fail(1)) SWIG_fail;
36525 {
36526 arg2 = static_cast<int >(SWIG_As_int(obj1));
36527 if (SWIG_arg_fail(2)) SWIG_fail;
36528 }
36529 {
36530 arg3 = wxString_in_helper(obj2);
36531 if (arg3 == NULL) SWIG_fail;
36532 temp3 = true;
36533 }
36534 {
36535 PyThreadState* __tstate = wxPyBeginAllowThreads();
36536 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
36537
36538 wxPyEndAllowThreads(__tstate);
36539 if (PyErr_Occurred()) SWIG_fail;
36540 }
36541 Py_INCREF(Py_None); resultobj = Py_None;
36542 {
36543 if (temp3)
36544 delete arg3;
36545 }
36546 return resultobj;
36547 fail:
36548 {
36549 if (temp3)
36550 delete arg3;
36551 }
36552 return NULL;
36553 }
36554
36555
36556 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36557 PyObject *resultobj = NULL;
36558 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36559 int arg2 ;
36560 wxString result;
36561 PyObject * obj0 = 0 ;
36562 PyObject * obj1 = 0 ;
36563 char *kwnames[] = {
36564 (char *) "self",(char *) "id", NULL
36565 };
36566
36567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
36568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36569 if (SWIG_arg_fail(1)) SWIG_fail;
36570 {
36571 arg2 = static_cast<int >(SWIG_As_int(obj1));
36572 if (SWIG_arg_fail(2)) SWIG_fail;
36573 }
36574 {
36575 PyThreadState* __tstate = wxPyBeginAllowThreads();
36576 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
36577
36578 wxPyEndAllowThreads(__tstate);
36579 if (PyErr_Occurred()) SWIG_fail;
36580 }
36581 {
36582 #if wxUSE_UNICODE
36583 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36584 #else
36585 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36586 #endif
36587 }
36588 return resultobj;
36589 fail:
36590 return NULL;
36591 }
36592
36593
36594 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
36595 PyObject *resultobj = NULL;
36596 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36597 wxFrame *result;
36598 PyObject * obj0 = 0 ;
36599 char *kwnames[] = {
36600 (char *) "self", NULL
36601 };
36602
36603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
36604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36605 if (SWIG_arg_fail(1)) SWIG_fail;
36606 {
36607 PyThreadState* __tstate = wxPyBeginAllowThreads();
36608 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
36609
36610 wxPyEndAllowThreads(__tstate);
36611 if (PyErr_Occurred()) SWIG_fail;
36612 }
36613 {
36614 resultobj = wxPyMake_wxObject(result, 0);
36615 }
36616 return resultobj;
36617 fail:
36618 return NULL;
36619 }
36620
36621
36622 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
36623 PyObject *resultobj = NULL;
36624 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36625 bool result;
36626 PyObject * obj0 = 0 ;
36627 char *kwnames[] = {
36628 (char *) "self", NULL
36629 };
36630
36631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
36632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36633 if (SWIG_arg_fail(1)) SWIG_fail;
36634 {
36635 PyThreadState* __tstate = wxPyBeginAllowThreads();
36636 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
36637
36638 wxPyEndAllowThreads(__tstate);
36639 if (PyErr_Occurred()) SWIG_fail;
36640 }
36641 {
36642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36643 }
36644 return resultobj;
36645 fail:
36646 return NULL;
36647 }
36648
36649
36650 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
36651 PyObject *resultobj = NULL;
36652 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36653 wxFrame *arg2 = (wxFrame *) 0 ;
36654 PyObject * obj0 = 0 ;
36655 PyObject * obj1 = 0 ;
36656 char *kwnames[] = {
36657 (char *) "self",(char *) "frame", NULL
36658 };
36659
36660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
36661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36662 if (SWIG_arg_fail(1)) SWIG_fail;
36663 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
36664 if (SWIG_arg_fail(2)) SWIG_fail;
36665 {
36666 PyThreadState* __tstate = wxPyBeginAllowThreads();
36667 (arg1)->Attach(arg2);
36668
36669 wxPyEndAllowThreads(__tstate);
36670 if (PyErr_Occurred()) SWIG_fail;
36671 }
36672 Py_INCREF(Py_None); resultobj = Py_None;
36673 return resultobj;
36674 fail:
36675 return NULL;
36676 }
36677
36678
36679 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
36680 PyObject *resultobj = NULL;
36681 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36682 PyObject * obj0 = 0 ;
36683 char *kwnames[] = {
36684 (char *) "self", NULL
36685 };
36686
36687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
36688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36689 if (SWIG_arg_fail(1)) SWIG_fail;
36690 {
36691 PyThreadState* __tstate = wxPyBeginAllowThreads();
36692 (arg1)->Detach();
36693
36694 wxPyEndAllowThreads(__tstate);
36695 if (PyErr_Occurred()) SWIG_fail;
36696 }
36697 Py_INCREF(Py_None); resultobj = Py_None;
36698 return resultobj;
36699 fail:
36700 return NULL;
36701 }
36702
36703
36704 static PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36705 PyObject *resultobj = NULL;
36706 bool arg1 ;
36707 PyObject * obj0 = 0 ;
36708 char *kwnames[] = {
36709 (char *) "enable", NULL
36710 };
36711
36712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) goto fail;
36713 {
36714 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
36715 if (SWIG_arg_fail(1)) SWIG_fail;
36716 }
36717 {
36718 PyThreadState* __tstate = wxPyBeginAllowThreads();
36719 wxMenuBar::SetAutoWindowMenu(arg1);
36720
36721 wxPyEndAllowThreads(__tstate);
36722 if (PyErr_Occurred()) SWIG_fail;
36723 }
36724 Py_INCREF(Py_None); resultobj = Py_None;
36725 return resultobj;
36726 fail:
36727 return NULL;
36728 }
36729
36730
36731 static PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36732 PyObject *resultobj = NULL;
36733 bool result;
36734 char *kwnames[] = {
36735 NULL
36736 };
36737
36738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuBar_GetAutoWindowMenu",kwnames)) goto fail;
36739 {
36740 PyThreadState* __tstate = wxPyBeginAllowThreads();
36741 result = (bool)wxMenuBar::GetAutoWindowMenu();
36742
36743 wxPyEndAllowThreads(__tstate);
36744 if (PyErr_Occurred()) SWIG_fail;
36745 }
36746 {
36747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36748 }
36749 return resultobj;
36750 fail:
36751 return NULL;
36752 }
36753
36754
36755 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
36756 PyObject *obj;
36757 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36758 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
36759 Py_INCREF(obj);
36760 return Py_BuildValue((char *)"");
36761 }
36762 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36763 PyObject *resultobj = NULL;
36764 wxMenu *arg1 = (wxMenu *) NULL ;
36765 int arg2 = (int) wxID_ANY ;
36766 wxString const &arg3_defvalue = wxPyEmptyString ;
36767 wxString *arg3 = (wxString *) &arg3_defvalue ;
36768 wxString const &arg4_defvalue = wxPyEmptyString ;
36769 wxString *arg4 = (wxString *) &arg4_defvalue ;
36770 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
36771 wxMenu *arg6 = (wxMenu *) NULL ;
36772 wxMenuItem *result;
36773 bool temp3 = false ;
36774 bool temp4 = false ;
36775 PyObject * obj0 = 0 ;
36776 PyObject * obj1 = 0 ;
36777 PyObject * obj2 = 0 ;
36778 PyObject * obj3 = 0 ;
36779 PyObject * obj4 = 0 ;
36780 PyObject * obj5 = 0 ;
36781 char *kwnames[] = {
36782 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
36783 };
36784
36785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
36786 if (obj0) {
36787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36788 if (SWIG_arg_fail(1)) SWIG_fail;
36789 }
36790 if (obj1) {
36791 {
36792 arg2 = static_cast<int >(SWIG_As_int(obj1));
36793 if (SWIG_arg_fail(2)) SWIG_fail;
36794 }
36795 }
36796 if (obj2) {
36797 {
36798 arg3 = wxString_in_helper(obj2);
36799 if (arg3 == NULL) SWIG_fail;
36800 temp3 = true;
36801 }
36802 }
36803 if (obj3) {
36804 {
36805 arg4 = wxString_in_helper(obj3);
36806 if (arg4 == NULL) SWIG_fail;
36807 temp4 = true;
36808 }
36809 }
36810 if (obj4) {
36811 {
36812 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
36813 if (SWIG_arg_fail(5)) SWIG_fail;
36814 }
36815 }
36816 if (obj5) {
36817 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36818 if (SWIG_arg_fail(6)) SWIG_fail;
36819 }
36820 {
36821 PyThreadState* __tstate = wxPyBeginAllowThreads();
36822 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
36823
36824 wxPyEndAllowThreads(__tstate);
36825 if (PyErr_Occurred()) SWIG_fail;
36826 }
36827 {
36828 resultobj = wxPyMake_wxObject(result, 1);
36829 }
36830 {
36831 if (temp3)
36832 delete arg3;
36833 }
36834 {
36835 if (temp4)
36836 delete arg4;
36837 }
36838 return resultobj;
36839 fail:
36840 {
36841 if (temp3)
36842 delete arg3;
36843 }
36844 {
36845 if (temp4)
36846 delete arg4;
36847 }
36848 return NULL;
36849 }
36850
36851
36852 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36853 PyObject *resultobj = NULL;
36854 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36855 wxMenu *result;
36856 PyObject * obj0 = 0 ;
36857 char *kwnames[] = {
36858 (char *) "self", NULL
36859 };
36860
36861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36863 if (SWIG_arg_fail(1)) SWIG_fail;
36864 {
36865 PyThreadState* __tstate = wxPyBeginAllowThreads();
36866 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36867
36868 wxPyEndAllowThreads(__tstate);
36869 if (PyErr_Occurred()) SWIG_fail;
36870 }
36871 {
36872 resultobj = wxPyMake_wxObject(result, 0);
36873 }
36874 return resultobj;
36875 fail:
36876 return NULL;
36877 }
36878
36879
36880 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36881 PyObject *resultobj = NULL;
36882 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36883 wxMenu *arg2 = (wxMenu *) 0 ;
36884 PyObject * obj0 = 0 ;
36885 PyObject * obj1 = 0 ;
36886 char *kwnames[] = {
36887 (char *) "self",(char *) "menu", NULL
36888 };
36889
36890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36892 if (SWIG_arg_fail(1)) SWIG_fail;
36893 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36894 if (SWIG_arg_fail(2)) SWIG_fail;
36895 {
36896 PyThreadState* __tstate = wxPyBeginAllowThreads();
36897 (arg1)->SetMenu(arg2);
36898
36899 wxPyEndAllowThreads(__tstate);
36900 if (PyErr_Occurred()) SWIG_fail;
36901 }
36902 Py_INCREF(Py_None); resultobj = Py_None;
36903 return resultobj;
36904 fail:
36905 return NULL;
36906 }
36907
36908
36909 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36910 PyObject *resultobj = NULL;
36911 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36912 int arg2 ;
36913 PyObject * obj0 = 0 ;
36914 PyObject * obj1 = 0 ;
36915 char *kwnames[] = {
36916 (char *) "self",(char *) "id", NULL
36917 };
36918
36919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36921 if (SWIG_arg_fail(1)) SWIG_fail;
36922 {
36923 arg2 = static_cast<int >(SWIG_As_int(obj1));
36924 if (SWIG_arg_fail(2)) SWIG_fail;
36925 }
36926 {
36927 PyThreadState* __tstate = wxPyBeginAllowThreads();
36928 (arg1)->SetId(arg2);
36929
36930 wxPyEndAllowThreads(__tstate);
36931 if (PyErr_Occurred()) SWIG_fail;
36932 }
36933 Py_INCREF(Py_None); resultobj = Py_None;
36934 return resultobj;
36935 fail:
36936 return NULL;
36937 }
36938
36939
36940 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36941 PyObject *resultobj = NULL;
36942 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36943 int result;
36944 PyObject * obj0 = 0 ;
36945 char *kwnames[] = {
36946 (char *) "self", NULL
36947 };
36948
36949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36951 if (SWIG_arg_fail(1)) SWIG_fail;
36952 {
36953 PyThreadState* __tstate = wxPyBeginAllowThreads();
36954 result = (int)((wxMenuItem const *)arg1)->GetId();
36955
36956 wxPyEndAllowThreads(__tstate);
36957 if (PyErr_Occurred()) SWIG_fail;
36958 }
36959 {
36960 resultobj = SWIG_From_int(static_cast<int >(result));
36961 }
36962 return resultobj;
36963 fail:
36964 return NULL;
36965 }
36966
36967
36968 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36969 PyObject *resultobj = NULL;
36970 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36971 bool result;
36972 PyObject * obj0 = 0 ;
36973 char *kwnames[] = {
36974 (char *) "self", NULL
36975 };
36976
36977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36979 if (SWIG_arg_fail(1)) SWIG_fail;
36980 {
36981 PyThreadState* __tstate = wxPyBeginAllowThreads();
36982 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36983
36984 wxPyEndAllowThreads(__tstate);
36985 if (PyErr_Occurred()) SWIG_fail;
36986 }
36987 {
36988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36989 }
36990 return resultobj;
36991 fail:
36992 return NULL;
36993 }
36994
36995
36996 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36997 PyObject *resultobj = NULL;
36998 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36999 wxString *arg2 = 0 ;
37000 bool temp2 = false ;
37001 PyObject * obj0 = 0 ;
37002 PyObject * obj1 = 0 ;
37003 char *kwnames[] = {
37004 (char *) "self",(char *) "str", NULL
37005 };
37006
37007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
37008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37009 if (SWIG_arg_fail(1)) SWIG_fail;
37010 {
37011 arg2 = wxString_in_helper(obj1);
37012 if (arg2 == NULL) SWIG_fail;
37013 temp2 = true;
37014 }
37015 {
37016 PyThreadState* __tstate = wxPyBeginAllowThreads();
37017 (arg1)->SetText((wxString const &)*arg2);
37018
37019 wxPyEndAllowThreads(__tstate);
37020 if (PyErr_Occurred()) SWIG_fail;
37021 }
37022 Py_INCREF(Py_None); resultobj = Py_None;
37023 {
37024 if (temp2)
37025 delete arg2;
37026 }
37027 return resultobj;
37028 fail:
37029 {
37030 if (temp2)
37031 delete arg2;
37032 }
37033 return NULL;
37034 }
37035
37036
37037 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37038 PyObject *resultobj = NULL;
37039 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37040 wxString result;
37041 PyObject * obj0 = 0 ;
37042 char *kwnames[] = {
37043 (char *) "self", NULL
37044 };
37045
37046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
37047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37048 if (SWIG_arg_fail(1)) SWIG_fail;
37049 {
37050 PyThreadState* __tstate = wxPyBeginAllowThreads();
37051 result = ((wxMenuItem const *)arg1)->GetLabel();
37052
37053 wxPyEndAllowThreads(__tstate);
37054 if (PyErr_Occurred()) SWIG_fail;
37055 }
37056 {
37057 #if wxUSE_UNICODE
37058 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37059 #else
37060 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37061 #endif
37062 }
37063 return resultobj;
37064 fail:
37065 return NULL;
37066 }
37067
37068
37069 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
37070 PyObject *resultobj = NULL;
37071 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37072 wxString *result;
37073 PyObject * obj0 = 0 ;
37074 char *kwnames[] = {
37075 (char *) "self", NULL
37076 };
37077
37078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
37079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37080 if (SWIG_arg_fail(1)) SWIG_fail;
37081 {
37082 PyThreadState* __tstate = wxPyBeginAllowThreads();
37083 {
37084 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
37085 result = (wxString *) &_result_ref;
37086 }
37087
37088 wxPyEndAllowThreads(__tstate);
37089 if (PyErr_Occurred()) SWIG_fail;
37090 }
37091 {
37092 #if wxUSE_UNICODE
37093 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37094 #else
37095 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37096 #endif
37097 }
37098 return resultobj;
37099 fail:
37100 return NULL;
37101 }
37102
37103
37104 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
37105 PyObject *resultobj = NULL;
37106 wxString *arg1 = 0 ;
37107 wxString result;
37108 bool temp1 = false ;
37109 PyObject * obj0 = 0 ;
37110 char *kwnames[] = {
37111 (char *) "text", NULL
37112 };
37113
37114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
37115 {
37116 arg1 = wxString_in_helper(obj0);
37117 if (arg1 == NULL) SWIG_fail;
37118 temp1 = true;
37119 }
37120 {
37121 PyThreadState* __tstate = wxPyBeginAllowThreads();
37122 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
37123
37124 wxPyEndAllowThreads(__tstate);
37125 if (PyErr_Occurred()) SWIG_fail;
37126 }
37127 {
37128 #if wxUSE_UNICODE
37129 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37130 #else
37131 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37132 #endif
37133 }
37134 {
37135 if (temp1)
37136 delete arg1;
37137 }
37138 return resultobj;
37139 fail:
37140 {
37141 if (temp1)
37142 delete arg1;
37143 }
37144 return NULL;
37145 }
37146
37147
37148 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
37149 PyObject *resultobj = NULL;
37150 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37151 wxItemKind result;
37152 PyObject * obj0 = 0 ;
37153 char *kwnames[] = {
37154 (char *) "self", NULL
37155 };
37156
37157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
37158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37159 if (SWIG_arg_fail(1)) SWIG_fail;
37160 {
37161 PyThreadState* __tstate = wxPyBeginAllowThreads();
37162 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
37163
37164 wxPyEndAllowThreads(__tstate);
37165 if (PyErr_Occurred()) SWIG_fail;
37166 }
37167 resultobj = SWIG_From_int((result));
37168 return resultobj;
37169 fail:
37170 return NULL;
37171 }
37172
37173
37174 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
37175 PyObject *resultobj = NULL;
37176 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37177 wxItemKind arg2 ;
37178 PyObject * obj0 = 0 ;
37179 PyObject * obj1 = 0 ;
37180 char *kwnames[] = {
37181 (char *) "self",(char *) "kind", NULL
37182 };
37183
37184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
37185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37186 if (SWIG_arg_fail(1)) SWIG_fail;
37187 {
37188 arg2 = static_cast<wxItemKind >(SWIG_As_int(obj1));
37189 if (SWIG_arg_fail(2)) SWIG_fail;
37190 }
37191 {
37192 PyThreadState* __tstate = wxPyBeginAllowThreads();
37193 (arg1)->SetKind(arg2);
37194
37195 wxPyEndAllowThreads(__tstate);
37196 if (PyErr_Occurred()) SWIG_fail;
37197 }
37198 Py_INCREF(Py_None); resultobj = Py_None;
37199 return resultobj;
37200 fail:
37201 return NULL;
37202 }
37203
37204
37205 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37206 PyObject *resultobj = NULL;
37207 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37208 bool arg2 ;
37209 PyObject * obj0 = 0 ;
37210 PyObject * obj1 = 0 ;
37211 char *kwnames[] = {
37212 (char *) "self",(char *) "checkable", NULL
37213 };
37214
37215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
37216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37217 if (SWIG_arg_fail(1)) SWIG_fail;
37218 {
37219 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37220 if (SWIG_arg_fail(2)) SWIG_fail;
37221 }
37222 {
37223 PyThreadState* __tstate = wxPyBeginAllowThreads();
37224 (arg1)->SetCheckable(arg2);
37225
37226 wxPyEndAllowThreads(__tstate);
37227 if (PyErr_Occurred()) SWIG_fail;
37228 }
37229 Py_INCREF(Py_None); resultobj = Py_None;
37230 return resultobj;
37231 fail:
37232 return NULL;
37233 }
37234
37235
37236 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37237 PyObject *resultobj = NULL;
37238 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37239 bool result;
37240 PyObject * obj0 = 0 ;
37241 char *kwnames[] = {
37242 (char *) "self", NULL
37243 };
37244
37245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
37246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37247 if (SWIG_arg_fail(1)) SWIG_fail;
37248 {
37249 PyThreadState* __tstate = wxPyBeginAllowThreads();
37250 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
37251
37252 wxPyEndAllowThreads(__tstate);
37253 if (PyErr_Occurred()) SWIG_fail;
37254 }
37255 {
37256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37257 }
37258 return resultobj;
37259 fail:
37260 return NULL;
37261 }
37262
37263
37264 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37265 PyObject *resultobj = NULL;
37266 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37267 bool result;
37268 PyObject * obj0 = 0 ;
37269 char *kwnames[] = {
37270 (char *) "self", NULL
37271 };
37272
37273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
37274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37275 if (SWIG_arg_fail(1)) SWIG_fail;
37276 {
37277 PyThreadState* __tstate = wxPyBeginAllowThreads();
37278 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
37279
37280 wxPyEndAllowThreads(__tstate);
37281 if (PyErr_Occurred()) SWIG_fail;
37282 }
37283 {
37284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37285 }
37286 return resultobj;
37287 fail:
37288 return NULL;
37289 }
37290
37291
37292 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37293 PyObject *resultobj = NULL;
37294 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37295 wxMenu *arg2 = (wxMenu *) 0 ;
37296 PyObject * obj0 = 0 ;
37297 PyObject * obj1 = 0 ;
37298 char *kwnames[] = {
37299 (char *) "self",(char *) "menu", NULL
37300 };
37301
37302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
37303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37304 if (SWIG_arg_fail(1)) SWIG_fail;
37305 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
37306 if (SWIG_arg_fail(2)) SWIG_fail;
37307 {
37308 PyThreadState* __tstate = wxPyBeginAllowThreads();
37309 (arg1)->SetSubMenu(arg2);
37310
37311 wxPyEndAllowThreads(__tstate);
37312 if (PyErr_Occurred()) SWIG_fail;
37313 }
37314 Py_INCREF(Py_None); resultobj = Py_None;
37315 return resultobj;
37316 fail:
37317 return NULL;
37318 }
37319
37320
37321 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37322 PyObject *resultobj = NULL;
37323 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37324 wxMenu *result;
37325 PyObject * obj0 = 0 ;
37326 char *kwnames[] = {
37327 (char *) "self", NULL
37328 };
37329
37330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
37331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37332 if (SWIG_arg_fail(1)) SWIG_fail;
37333 {
37334 PyThreadState* __tstate = wxPyBeginAllowThreads();
37335 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
37336
37337 wxPyEndAllowThreads(__tstate);
37338 if (PyErr_Occurred()) SWIG_fail;
37339 }
37340 {
37341 resultobj = wxPyMake_wxObject(result, 0);
37342 }
37343 return resultobj;
37344 fail:
37345 return NULL;
37346 }
37347
37348
37349 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
37350 PyObject *resultobj = NULL;
37351 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37352 bool arg2 = (bool) true ;
37353 PyObject * obj0 = 0 ;
37354 PyObject * obj1 = 0 ;
37355 char *kwnames[] = {
37356 (char *) "self",(char *) "enable", NULL
37357 };
37358
37359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
37360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37361 if (SWIG_arg_fail(1)) SWIG_fail;
37362 if (obj1) {
37363 {
37364 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37365 if (SWIG_arg_fail(2)) SWIG_fail;
37366 }
37367 }
37368 {
37369 PyThreadState* __tstate = wxPyBeginAllowThreads();
37370 (arg1)->Enable(arg2);
37371
37372 wxPyEndAllowThreads(__tstate);
37373 if (PyErr_Occurred()) SWIG_fail;
37374 }
37375 Py_INCREF(Py_None); resultobj = Py_None;
37376 return resultobj;
37377 fail:
37378 return NULL;
37379 }
37380
37381
37382 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
37383 PyObject *resultobj = NULL;
37384 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37385 bool result;
37386 PyObject * obj0 = 0 ;
37387 char *kwnames[] = {
37388 (char *) "self", NULL
37389 };
37390
37391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
37392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37393 if (SWIG_arg_fail(1)) SWIG_fail;
37394 {
37395 PyThreadState* __tstate = wxPyBeginAllowThreads();
37396 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
37397
37398 wxPyEndAllowThreads(__tstate);
37399 if (PyErr_Occurred()) SWIG_fail;
37400 }
37401 {
37402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37403 }
37404 return resultobj;
37405 fail:
37406 return NULL;
37407 }
37408
37409
37410 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
37411 PyObject *resultobj = NULL;
37412 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37413 bool arg2 = (bool) true ;
37414 PyObject * obj0 = 0 ;
37415 PyObject * obj1 = 0 ;
37416 char *kwnames[] = {
37417 (char *) "self",(char *) "check", NULL
37418 };
37419
37420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
37421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37422 if (SWIG_arg_fail(1)) SWIG_fail;
37423 if (obj1) {
37424 {
37425 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37426 if (SWIG_arg_fail(2)) SWIG_fail;
37427 }
37428 }
37429 {
37430 PyThreadState* __tstate = wxPyBeginAllowThreads();
37431 (arg1)->Check(arg2);
37432
37433 wxPyEndAllowThreads(__tstate);
37434 if (PyErr_Occurred()) SWIG_fail;
37435 }
37436 Py_INCREF(Py_None); resultobj = Py_None;
37437 return resultobj;
37438 fail:
37439 return NULL;
37440 }
37441
37442
37443 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
37444 PyObject *resultobj = NULL;
37445 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37446 bool result;
37447 PyObject * obj0 = 0 ;
37448 char *kwnames[] = {
37449 (char *) "self", NULL
37450 };
37451
37452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
37453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37454 if (SWIG_arg_fail(1)) SWIG_fail;
37455 {
37456 PyThreadState* __tstate = wxPyBeginAllowThreads();
37457 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
37458
37459 wxPyEndAllowThreads(__tstate);
37460 if (PyErr_Occurred()) SWIG_fail;
37461 }
37462 {
37463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37464 }
37465 return resultobj;
37466 fail:
37467 return NULL;
37468 }
37469
37470
37471 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
37472 PyObject *resultobj = NULL;
37473 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37474 PyObject * obj0 = 0 ;
37475 char *kwnames[] = {
37476 (char *) "self", NULL
37477 };
37478
37479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
37480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37481 if (SWIG_arg_fail(1)) SWIG_fail;
37482 {
37483 PyThreadState* __tstate = wxPyBeginAllowThreads();
37484 (arg1)->Toggle();
37485
37486 wxPyEndAllowThreads(__tstate);
37487 if (PyErr_Occurred()) SWIG_fail;
37488 }
37489 Py_INCREF(Py_None); resultobj = Py_None;
37490 return resultobj;
37491 fail:
37492 return NULL;
37493 }
37494
37495
37496 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37497 PyObject *resultobj = NULL;
37498 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37499 wxString *arg2 = 0 ;
37500 bool temp2 = false ;
37501 PyObject * obj0 = 0 ;
37502 PyObject * obj1 = 0 ;
37503 char *kwnames[] = {
37504 (char *) "self",(char *) "str", NULL
37505 };
37506
37507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
37508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37509 if (SWIG_arg_fail(1)) SWIG_fail;
37510 {
37511 arg2 = wxString_in_helper(obj1);
37512 if (arg2 == NULL) SWIG_fail;
37513 temp2 = true;
37514 }
37515 {
37516 PyThreadState* __tstate = wxPyBeginAllowThreads();
37517 (arg1)->SetHelp((wxString const &)*arg2);
37518
37519 wxPyEndAllowThreads(__tstate);
37520 if (PyErr_Occurred()) SWIG_fail;
37521 }
37522 Py_INCREF(Py_None); resultobj = Py_None;
37523 {
37524 if (temp2)
37525 delete arg2;
37526 }
37527 return resultobj;
37528 fail:
37529 {
37530 if (temp2)
37531 delete arg2;
37532 }
37533 return NULL;
37534 }
37535
37536
37537 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37538 PyObject *resultobj = NULL;
37539 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37540 wxString *result;
37541 PyObject * obj0 = 0 ;
37542 char *kwnames[] = {
37543 (char *) "self", NULL
37544 };
37545
37546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
37547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37548 if (SWIG_arg_fail(1)) SWIG_fail;
37549 {
37550 PyThreadState* __tstate = wxPyBeginAllowThreads();
37551 {
37552 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
37553 result = (wxString *) &_result_ref;
37554 }
37555
37556 wxPyEndAllowThreads(__tstate);
37557 if (PyErr_Occurred()) SWIG_fail;
37558 }
37559 {
37560 #if wxUSE_UNICODE
37561 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37562 #else
37563 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37564 #endif
37565 }
37566 return resultobj;
37567 fail:
37568 return NULL;
37569 }
37570
37571
37572 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37573 PyObject *resultobj = NULL;
37574 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37575 wxAcceleratorEntry *result;
37576 PyObject * obj0 = 0 ;
37577 char *kwnames[] = {
37578 (char *) "self", NULL
37579 };
37580
37581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
37582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37583 if (SWIG_arg_fail(1)) SWIG_fail;
37584 {
37585 PyThreadState* __tstate = wxPyBeginAllowThreads();
37586 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
37587
37588 wxPyEndAllowThreads(__tstate);
37589 if (PyErr_Occurred()) SWIG_fail;
37590 }
37591 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
37592 return resultobj;
37593 fail:
37594 return NULL;
37595 }
37596
37597
37598 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37599 PyObject *resultobj = NULL;
37600 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37601 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
37602 PyObject * obj0 = 0 ;
37603 PyObject * obj1 = 0 ;
37604 char *kwnames[] = {
37605 (char *) "self",(char *) "accel", NULL
37606 };
37607
37608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
37609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37610 if (SWIG_arg_fail(1)) SWIG_fail;
37611 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
37612 if (SWIG_arg_fail(2)) SWIG_fail;
37613 {
37614 PyThreadState* __tstate = wxPyBeginAllowThreads();
37615 (arg1)->SetAccel(arg2);
37616
37617 wxPyEndAllowThreads(__tstate);
37618 if (PyErr_Occurred()) SWIG_fail;
37619 }
37620 Py_INCREF(Py_None); resultobj = Py_None;
37621 return resultobj;
37622 fail:
37623 return NULL;
37624 }
37625
37626
37627 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37628 PyObject *resultobj = NULL;
37629 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37630 wxBitmap *arg2 = 0 ;
37631 PyObject * obj0 = 0 ;
37632 PyObject * obj1 = 0 ;
37633 char *kwnames[] = {
37634 (char *) "self",(char *) "bitmap", NULL
37635 };
37636
37637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37639 if (SWIG_arg_fail(1)) SWIG_fail;
37640 {
37641 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37642 if (SWIG_arg_fail(2)) SWIG_fail;
37643 if (arg2 == NULL) {
37644 SWIG_null_ref("wxBitmap");
37645 }
37646 if (SWIG_arg_fail(2)) SWIG_fail;
37647 }
37648 {
37649 PyThreadState* __tstate = wxPyBeginAllowThreads();
37650 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37651
37652 wxPyEndAllowThreads(__tstate);
37653 if (PyErr_Occurred()) SWIG_fail;
37654 }
37655 Py_INCREF(Py_None); resultobj = Py_None;
37656 return resultobj;
37657 fail:
37658 return NULL;
37659 }
37660
37661
37662 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37663 PyObject *resultobj = NULL;
37664 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37665 wxBitmap *result;
37666 PyObject * obj0 = 0 ;
37667 char *kwnames[] = {
37668 (char *) "self", NULL
37669 };
37670
37671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37673 if (SWIG_arg_fail(1)) SWIG_fail;
37674 {
37675 PyThreadState* __tstate = wxPyBeginAllowThreads();
37676 {
37677 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37678 result = (wxBitmap *) &_result_ref;
37679 }
37680
37681 wxPyEndAllowThreads(__tstate);
37682 if (PyErr_Occurred()) SWIG_fail;
37683 }
37684 {
37685 wxBitmap* resultptr = new wxBitmap(*result);
37686 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37687 }
37688 return resultobj;
37689 fail:
37690 return NULL;
37691 }
37692
37693
37694 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37695 PyObject *resultobj = NULL;
37696 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37697 wxFont *arg2 = 0 ;
37698 PyObject * obj0 = 0 ;
37699 PyObject * obj1 = 0 ;
37700 char *kwnames[] = {
37701 (char *) "self",(char *) "font", NULL
37702 };
37703
37704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
37705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37706 if (SWIG_arg_fail(1)) SWIG_fail;
37707 {
37708 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
37709 if (SWIG_arg_fail(2)) SWIG_fail;
37710 if (arg2 == NULL) {
37711 SWIG_null_ref("wxFont");
37712 }
37713 if (SWIG_arg_fail(2)) SWIG_fail;
37714 }
37715 {
37716 PyThreadState* __tstate = wxPyBeginAllowThreads();
37717 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
37718
37719 wxPyEndAllowThreads(__tstate);
37720 if (PyErr_Occurred()) SWIG_fail;
37721 }
37722 Py_INCREF(Py_None); resultobj = Py_None;
37723 return resultobj;
37724 fail:
37725 return NULL;
37726 }
37727
37728
37729 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37730 PyObject *resultobj = NULL;
37731 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37732 wxFont result;
37733 PyObject * obj0 = 0 ;
37734 char *kwnames[] = {
37735 (char *) "self", NULL
37736 };
37737
37738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
37739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37740 if (SWIG_arg_fail(1)) SWIG_fail;
37741 {
37742 PyThreadState* __tstate = wxPyBeginAllowThreads();
37743 result = wxMenuItem_GetFont(arg1);
37744
37745 wxPyEndAllowThreads(__tstate);
37746 if (PyErr_Occurred()) SWIG_fail;
37747 }
37748 {
37749 wxFont * resultptr;
37750 resultptr = new wxFont(static_cast<wxFont & >(result));
37751 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
37752 }
37753 return resultobj;
37754 fail:
37755 return NULL;
37756 }
37757
37758
37759 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37760 PyObject *resultobj = NULL;
37761 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37762 wxColour *arg2 = 0 ;
37763 wxColour temp2 ;
37764 PyObject * obj0 = 0 ;
37765 PyObject * obj1 = 0 ;
37766 char *kwnames[] = {
37767 (char *) "self",(char *) "colText", NULL
37768 };
37769
37770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
37771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37772 if (SWIG_arg_fail(1)) SWIG_fail;
37773 {
37774 arg2 = &temp2;
37775 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37776 }
37777 {
37778 PyThreadState* __tstate = wxPyBeginAllowThreads();
37779 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
37780
37781 wxPyEndAllowThreads(__tstate);
37782 if (PyErr_Occurred()) SWIG_fail;
37783 }
37784 Py_INCREF(Py_None); resultobj = Py_None;
37785 return resultobj;
37786 fail:
37787 return NULL;
37788 }
37789
37790
37791 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37792 PyObject *resultobj = NULL;
37793 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37794 wxColour result;
37795 PyObject * obj0 = 0 ;
37796 char *kwnames[] = {
37797 (char *) "self", NULL
37798 };
37799
37800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
37801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37802 if (SWIG_arg_fail(1)) SWIG_fail;
37803 {
37804 PyThreadState* __tstate = wxPyBeginAllowThreads();
37805 result = wxMenuItem_GetTextColour(arg1);
37806
37807 wxPyEndAllowThreads(__tstate);
37808 if (PyErr_Occurred()) SWIG_fail;
37809 }
37810 {
37811 wxColour * resultptr;
37812 resultptr = new wxColour(static_cast<wxColour & >(result));
37813 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37814 }
37815 return resultobj;
37816 fail:
37817 return NULL;
37818 }
37819
37820
37821 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37822 PyObject *resultobj = NULL;
37823 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37824 wxColour *arg2 = 0 ;
37825 wxColour temp2 ;
37826 PyObject * obj0 = 0 ;
37827 PyObject * obj1 = 0 ;
37828 char *kwnames[] = {
37829 (char *) "self",(char *) "colBack", NULL
37830 };
37831
37832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
37833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37834 if (SWIG_arg_fail(1)) SWIG_fail;
37835 {
37836 arg2 = &temp2;
37837 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37838 }
37839 {
37840 PyThreadState* __tstate = wxPyBeginAllowThreads();
37841 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
37842
37843 wxPyEndAllowThreads(__tstate);
37844 if (PyErr_Occurred()) SWIG_fail;
37845 }
37846 Py_INCREF(Py_None); resultobj = Py_None;
37847 return resultobj;
37848 fail:
37849 return NULL;
37850 }
37851
37852
37853 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37854 PyObject *resultobj = NULL;
37855 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37856 wxColour result;
37857 PyObject * obj0 = 0 ;
37858 char *kwnames[] = {
37859 (char *) "self", NULL
37860 };
37861
37862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
37863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37864 if (SWIG_arg_fail(1)) SWIG_fail;
37865 {
37866 PyThreadState* __tstate = wxPyBeginAllowThreads();
37867 result = wxMenuItem_GetBackgroundColour(arg1);
37868
37869 wxPyEndAllowThreads(__tstate);
37870 if (PyErr_Occurred()) SWIG_fail;
37871 }
37872 {
37873 wxColour * resultptr;
37874 resultptr = new wxColour(static_cast<wxColour & >(result));
37875 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37876 }
37877 return resultobj;
37878 fail:
37879 return NULL;
37880 }
37881
37882
37883 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
37884 PyObject *resultobj = NULL;
37885 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37886 wxBitmap *arg2 = 0 ;
37887 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37888 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37889 PyObject * obj0 = 0 ;
37890 PyObject * obj1 = 0 ;
37891 PyObject * obj2 = 0 ;
37892 char *kwnames[] = {
37893 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37894 };
37895
37896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37898 if (SWIG_arg_fail(1)) SWIG_fail;
37899 {
37900 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37901 if (SWIG_arg_fail(2)) SWIG_fail;
37902 if (arg2 == NULL) {
37903 SWIG_null_ref("wxBitmap");
37904 }
37905 if (SWIG_arg_fail(2)) SWIG_fail;
37906 }
37907 if (obj2) {
37908 {
37909 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37910 if (SWIG_arg_fail(3)) SWIG_fail;
37911 if (arg3 == NULL) {
37912 SWIG_null_ref("wxBitmap");
37913 }
37914 if (SWIG_arg_fail(3)) SWIG_fail;
37915 }
37916 }
37917 {
37918 PyThreadState* __tstate = wxPyBeginAllowThreads();
37919 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37920
37921 wxPyEndAllowThreads(__tstate);
37922 if (PyErr_Occurred()) SWIG_fail;
37923 }
37924 Py_INCREF(Py_None); resultobj = Py_None;
37925 return resultobj;
37926 fail:
37927 return NULL;
37928 }
37929
37930
37931 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37932 PyObject *resultobj = NULL;
37933 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37934 wxBitmap *arg2 = 0 ;
37935 PyObject * obj0 = 0 ;
37936 PyObject * obj1 = 0 ;
37937 char *kwnames[] = {
37938 (char *) "self",(char *) "bmpDisabled", NULL
37939 };
37940
37941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37943 if (SWIG_arg_fail(1)) SWIG_fail;
37944 {
37945 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37946 if (SWIG_arg_fail(2)) SWIG_fail;
37947 if (arg2 == NULL) {
37948 SWIG_null_ref("wxBitmap");
37949 }
37950 if (SWIG_arg_fail(2)) SWIG_fail;
37951 }
37952 {
37953 PyThreadState* __tstate = wxPyBeginAllowThreads();
37954 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
37955
37956 wxPyEndAllowThreads(__tstate);
37957 if (PyErr_Occurred()) SWIG_fail;
37958 }
37959 Py_INCREF(Py_None); resultobj = Py_None;
37960 return resultobj;
37961 fail:
37962 return NULL;
37963 }
37964
37965
37966 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37967 PyObject *resultobj = NULL;
37968 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37969 wxBitmap *result;
37970 PyObject * obj0 = 0 ;
37971 char *kwnames[] = {
37972 (char *) "self", NULL
37973 };
37974
37975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37977 if (SWIG_arg_fail(1)) SWIG_fail;
37978 {
37979 PyThreadState* __tstate = wxPyBeginAllowThreads();
37980 {
37981 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
37982 result = (wxBitmap *) &_result_ref;
37983 }
37984
37985 wxPyEndAllowThreads(__tstate);
37986 if (PyErr_Occurred()) SWIG_fail;
37987 }
37988 {
37989 wxBitmap* resultptr = new wxBitmap(*result);
37990 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37991 }
37992 return resultobj;
37993 fail:
37994 return NULL;
37995 }
37996
37997
37998 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37999 PyObject *resultobj = NULL;
38000 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38001 int arg2 ;
38002 PyObject * obj0 = 0 ;
38003 PyObject * obj1 = 0 ;
38004 char *kwnames[] = {
38005 (char *) "self",(char *) "nWidth", NULL
38006 };
38007
38008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
38009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38010 if (SWIG_arg_fail(1)) SWIG_fail;
38011 {
38012 arg2 = static_cast<int >(SWIG_As_int(obj1));
38013 if (SWIG_arg_fail(2)) SWIG_fail;
38014 }
38015 {
38016 PyThreadState* __tstate = wxPyBeginAllowThreads();
38017 wxMenuItem_SetMarginWidth(arg1,arg2);
38018
38019 wxPyEndAllowThreads(__tstate);
38020 if (PyErr_Occurred()) SWIG_fail;
38021 }
38022 Py_INCREF(Py_None); resultobj = Py_None;
38023 return resultobj;
38024 fail:
38025 return NULL;
38026 }
38027
38028
38029 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38030 PyObject *resultobj = NULL;
38031 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38032 int result;
38033 PyObject * obj0 = 0 ;
38034 char *kwnames[] = {
38035 (char *) "self", NULL
38036 };
38037
38038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
38039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38040 if (SWIG_arg_fail(1)) SWIG_fail;
38041 {
38042 PyThreadState* __tstate = wxPyBeginAllowThreads();
38043 result = (int)wxMenuItem_GetMarginWidth(arg1);
38044
38045 wxPyEndAllowThreads(__tstate);
38046 if (PyErr_Occurred()) SWIG_fail;
38047 }
38048 {
38049 resultobj = SWIG_From_int(static_cast<int >(result));
38050 }
38051 return resultobj;
38052 fail:
38053 return NULL;
38054 }
38055
38056
38057 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38058 PyObject *resultobj = NULL;
38059 int result;
38060 char *kwnames[] = {
38061 NULL
38062 };
38063
38064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
38065 {
38066 PyThreadState* __tstate = wxPyBeginAllowThreads();
38067 result = (int)wxMenuItem_GetDefaultMarginWidth();
38068
38069 wxPyEndAllowThreads(__tstate);
38070 if (PyErr_Occurred()) SWIG_fail;
38071 }
38072 {
38073 resultobj = SWIG_From_int(static_cast<int >(result));
38074 }
38075 return resultobj;
38076 fail:
38077 return NULL;
38078 }
38079
38080
38081 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38082 PyObject *resultobj = NULL;
38083 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38084 bool result;
38085 PyObject * obj0 = 0 ;
38086 char *kwnames[] = {
38087 (char *) "self", NULL
38088 };
38089
38090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
38091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38092 if (SWIG_arg_fail(1)) SWIG_fail;
38093 {
38094 PyThreadState* __tstate = wxPyBeginAllowThreads();
38095 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
38096
38097 wxPyEndAllowThreads(__tstate);
38098 if (PyErr_Occurred()) SWIG_fail;
38099 }
38100 {
38101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38102 }
38103 return resultobj;
38104 fail:
38105 return NULL;
38106 }
38107
38108
38109 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38110 PyObject *resultobj = NULL;
38111 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38112 bool arg2 = (bool) true ;
38113 PyObject * obj0 = 0 ;
38114 PyObject * obj1 = 0 ;
38115 char *kwnames[] = {
38116 (char *) "self",(char *) "ownerDrawn", NULL
38117 };
38118
38119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
38120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38121 if (SWIG_arg_fail(1)) SWIG_fail;
38122 if (obj1) {
38123 {
38124 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
38125 if (SWIG_arg_fail(2)) SWIG_fail;
38126 }
38127 }
38128 {
38129 PyThreadState* __tstate = wxPyBeginAllowThreads();
38130 wxMenuItem_SetOwnerDrawn(arg1,arg2);
38131
38132 wxPyEndAllowThreads(__tstate);
38133 if (PyErr_Occurred()) SWIG_fail;
38134 }
38135 Py_INCREF(Py_None); resultobj = Py_None;
38136 return resultobj;
38137 fail:
38138 return NULL;
38139 }
38140
38141
38142 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38143 PyObject *resultobj = NULL;
38144 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38145 PyObject * obj0 = 0 ;
38146 char *kwnames[] = {
38147 (char *) "self", NULL
38148 };
38149
38150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
38151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38152 if (SWIG_arg_fail(1)) SWIG_fail;
38153 {
38154 PyThreadState* __tstate = wxPyBeginAllowThreads();
38155 wxMenuItem_ResetOwnerDrawn(arg1);
38156
38157 wxPyEndAllowThreads(__tstate);
38158 if (PyErr_Occurred()) SWIG_fail;
38159 }
38160 Py_INCREF(Py_None); resultobj = Py_None;
38161 return resultobj;
38162 fail:
38163 return NULL;
38164 }
38165
38166
38167 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
38168 PyObject *obj;
38169 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38170 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
38171 Py_INCREF(obj);
38172 return Py_BuildValue((char *)"");
38173 }
38174 static int _wrap_ControlNameStr_set(PyObject *) {
38175 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
38176 return 1;
38177 }
38178
38179
38180 static PyObject *_wrap_ControlNameStr_get(void) {
38181 PyObject *pyobj = NULL;
38182
38183 {
38184 #if wxUSE_UNICODE
38185 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
38186 #else
38187 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
38188 #endif
38189 }
38190 return pyobj;
38191 }
38192
38193
38194 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
38195 PyObject *resultobj = NULL;
38196 wxWindow *arg1 = (wxWindow *) 0 ;
38197 int arg2 = (int) -1 ;
38198 wxPoint const &arg3_defvalue = wxDefaultPosition ;
38199 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
38200 wxSize const &arg4_defvalue = wxDefaultSize ;
38201 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
38202 long arg5 = (long) 0 ;
38203 wxValidator const &arg6_defvalue = wxDefaultValidator ;
38204 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
38205 wxString const &arg7_defvalue = wxPyControlNameStr ;
38206 wxString *arg7 = (wxString *) &arg7_defvalue ;
38207 wxControl *result;
38208 wxPoint temp3 ;
38209 wxSize temp4 ;
38210 bool temp7 = false ;
38211 PyObject * obj0 = 0 ;
38212 PyObject * obj1 = 0 ;
38213 PyObject * obj2 = 0 ;
38214 PyObject * obj3 = 0 ;
38215 PyObject * obj4 = 0 ;
38216 PyObject * obj5 = 0 ;
38217 PyObject * obj6 = 0 ;
38218 char *kwnames[] = {
38219 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38220 };
38221
38222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38224 if (SWIG_arg_fail(1)) SWIG_fail;
38225 if (obj1) {
38226 {
38227 arg2 = static_cast<int >(SWIG_As_int(obj1));
38228 if (SWIG_arg_fail(2)) SWIG_fail;
38229 }
38230 }
38231 if (obj2) {
38232 {
38233 arg3 = &temp3;
38234 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
38235 }
38236 }
38237 if (obj3) {
38238 {
38239 arg4 = &temp4;
38240 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
38241 }
38242 }
38243 if (obj4) {
38244 {
38245 arg5 = static_cast<long >(SWIG_As_long(obj4));
38246 if (SWIG_arg_fail(5)) SWIG_fail;
38247 }
38248 }
38249 if (obj5) {
38250 {
38251 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38252 if (SWIG_arg_fail(6)) SWIG_fail;
38253 if (arg6 == NULL) {
38254 SWIG_null_ref("wxValidator");
38255 }
38256 if (SWIG_arg_fail(6)) SWIG_fail;
38257 }
38258 }
38259 if (obj6) {
38260 {
38261 arg7 = wxString_in_helper(obj6);
38262 if (arg7 == NULL) SWIG_fail;
38263 temp7 = true;
38264 }
38265 }
38266 {
38267 if (!wxPyCheckForApp()) SWIG_fail;
38268 PyThreadState* __tstate = wxPyBeginAllowThreads();
38269 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
38270
38271 wxPyEndAllowThreads(__tstate);
38272 if (PyErr_Occurred()) SWIG_fail;
38273 }
38274 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38275 {
38276 if (temp7)
38277 delete arg7;
38278 }
38279 return resultobj;
38280 fail:
38281 {
38282 if (temp7)
38283 delete arg7;
38284 }
38285 return NULL;
38286 }
38287
38288
38289 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
38290 PyObject *resultobj = NULL;
38291 wxControl *result;
38292 char *kwnames[] = {
38293 NULL
38294 };
38295
38296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
38297 {
38298 if (!wxPyCheckForApp()) SWIG_fail;
38299 PyThreadState* __tstate = wxPyBeginAllowThreads();
38300 result = (wxControl *)new wxControl();
38301
38302 wxPyEndAllowThreads(__tstate);
38303 if (PyErr_Occurred()) SWIG_fail;
38304 }
38305 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38306 return resultobj;
38307 fail:
38308 return NULL;
38309 }
38310
38311
38312 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
38313 PyObject *resultobj = NULL;
38314 wxControl *arg1 = (wxControl *) 0 ;
38315 wxWindow *arg2 = (wxWindow *) 0 ;
38316 int arg3 = (int) -1 ;
38317 wxPoint const &arg4_defvalue = wxDefaultPosition ;
38318 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
38319 wxSize const &arg5_defvalue = wxDefaultSize ;
38320 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
38321 long arg6 = (long) 0 ;
38322 wxValidator const &arg7_defvalue = wxDefaultValidator ;
38323 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
38324 wxString const &arg8_defvalue = wxPyControlNameStr ;
38325 wxString *arg8 = (wxString *) &arg8_defvalue ;
38326 bool result;
38327 wxPoint temp4 ;
38328 wxSize temp5 ;
38329 bool temp8 = false ;
38330 PyObject * obj0 = 0 ;
38331 PyObject * obj1 = 0 ;
38332 PyObject * obj2 = 0 ;
38333 PyObject * obj3 = 0 ;
38334 PyObject * obj4 = 0 ;
38335 PyObject * obj5 = 0 ;
38336 PyObject * obj6 = 0 ;
38337 PyObject * obj7 = 0 ;
38338 char *kwnames[] = {
38339 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38340 };
38341
38342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
38343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38344 if (SWIG_arg_fail(1)) SWIG_fail;
38345 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38346 if (SWIG_arg_fail(2)) SWIG_fail;
38347 if (obj2) {
38348 {
38349 arg3 = static_cast<int >(SWIG_As_int(obj2));
38350 if (SWIG_arg_fail(3)) SWIG_fail;
38351 }
38352 }
38353 if (obj3) {
38354 {
38355 arg4 = &temp4;
38356 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
38357 }
38358 }
38359 if (obj4) {
38360 {
38361 arg5 = &temp5;
38362 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
38363 }
38364 }
38365 if (obj5) {
38366 {
38367 arg6 = static_cast<long >(SWIG_As_long(obj5));
38368 if (SWIG_arg_fail(6)) SWIG_fail;
38369 }
38370 }
38371 if (obj6) {
38372 {
38373 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38374 if (SWIG_arg_fail(7)) SWIG_fail;
38375 if (arg7 == NULL) {
38376 SWIG_null_ref("wxValidator");
38377 }
38378 if (SWIG_arg_fail(7)) SWIG_fail;
38379 }
38380 }
38381 if (obj7) {
38382 {
38383 arg8 = wxString_in_helper(obj7);
38384 if (arg8 == NULL) SWIG_fail;
38385 temp8 = true;
38386 }
38387 }
38388 {
38389 PyThreadState* __tstate = wxPyBeginAllowThreads();
38390 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
38391
38392 wxPyEndAllowThreads(__tstate);
38393 if (PyErr_Occurred()) SWIG_fail;
38394 }
38395 {
38396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38397 }
38398 {
38399 if (temp8)
38400 delete arg8;
38401 }
38402 return resultobj;
38403 fail:
38404 {
38405 if (temp8)
38406 delete arg8;
38407 }
38408 return NULL;
38409 }
38410
38411
38412 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
38413 PyObject *resultobj = NULL;
38414 wxControl *arg1 = (wxControl *) 0 ;
38415 wxCommandEvent *arg2 = 0 ;
38416 PyObject * obj0 = 0 ;
38417 PyObject * obj1 = 0 ;
38418 char *kwnames[] = {
38419 (char *) "self",(char *) "event", NULL
38420 };
38421
38422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
38423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38424 if (SWIG_arg_fail(1)) SWIG_fail;
38425 {
38426 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
38427 if (SWIG_arg_fail(2)) SWIG_fail;
38428 if (arg2 == NULL) {
38429 SWIG_null_ref("wxCommandEvent");
38430 }
38431 if (SWIG_arg_fail(2)) SWIG_fail;
38432 }
38433 {
38434 PyThreadState* __tstate = wxPyBeginAllowThreads();
38435 (arg1)->Command(*arg2);
38436
38437 wxPyEndAllowThreads(__tstate);
38438 if (PyErr_Occurred()) SWIG_fail;
38439 }
38440 Py_INCREF(Py_None); resultobj = Py_None;
38441 return resultobj;
38442 fail:
38443 return NULL;
38444 }
38445
38446
38447 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38448 PyObject *resultobj = NULL;
38449 wxControl *arg1 = (wxControl *) 0 ;
38450 wxString result;
38451 PyObject * obj0 = 0 ;
38452 char *kwnames[] = {
38453 (char *) "self", NULL
38454 };
38455
38456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
38457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38458 if (SWIG_arg_fail(1)) SWIG_fail;
38459 {
38460 PyThreadState* __tstate = wxPyBeginAllowThreads();
38461 result = (arg1)->GetLabel();
38462
38463 wxPyEndAllowThreads(__tstate);
38464 if (PyErr_Occurred()) SWIG_fail;
38465 }
38466 {
38467 #if wxUSE_UNICODE
38468 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38469 #else
38470 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38471 #endif
38472 }
38473 return resultobj;
38474 fail:
38475 return NULL;
38476 }
38477
38478
38479 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38480 PyObject *resultobj = NULL;
38481 wxControl *arg1 = (wxControl *) 0 ;
38482 wxString *arg2 = 0 ;
38483 bool temp2 = false ;
38484 PyObject * obj0 = 0 ;
38485 PyObject * obj1 = 0 ;
38486 char *kwnames[] = {
38487 (char *) "self",(char *) "label", NULL
38488 };
38489
38490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
38491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38492 if (SWIG_arg_fail(1)) SWIG_fail;
38493 {
38494 arg2 = wxString_in_helper(obj1);
38495 if (arg2 == NULL) SWIG_fail;
38496 temp2 = true;
38497 }
38498 {
38499 PyThreadState* __tstate = wxPyBeginAllowThreads();
38500 (arg1)->SetLabel((wxString const &)*arg2);
38501
38502 wxPyEndAllowThreads(__tstate);
38503 if (PyErr_Occurred()) SWIG_fail;
38504 }
38505 Py_INCREF(Py_None); resultobj = Py_None;
38506 {
38507 if (temp2)
38508 delete arg2;
38509 }
38510 return resultobj;
38511 fail:
38512 {
38513 if (temp2)
38514 delete arg2;
38515 }
38516 return NULL;
38517 }
38518
38519
38520 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
38521 PyObject *resultobj = NULL;
38522 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38523 wxVisualAttributes result;
38524 PyObject * obj0 = 0 ;
38525 char *kwnames[] = {
38526 (char *) "variant", NULL
38527 };
38528
38529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
38530 if (obj0) {
38531 {
38532 arg1 = static_cast<wxWindowVariant >(SWIG_As_int(obj0));
38533 if (SWIG_arg_fail(1)) SWIG_fail;
38534 }
38535 }
38536 {
38537 if (!wxPyCheckForApp()) SWIG_fail;
38538 PyThreadState* __tstate = wxPyBeginAllowThreads();
38539 result = wxControl::GetClassDefaultAttributes(arg1);
38540
38541 wxPyEndAllowThreads(__tstate);
38542 if (PyErr_Occurred()) SWIG_fail;
38543 }
38544 {
38545 wxVisualAttributes * resultptr;
38546 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
38547 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
38548 }
38549 return resultobj;
38550 fail:
38551 return NULL;
38552 }
38553
38554
38555 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
38556 PyObject *obj;
38557 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38558 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
38559 Py_INCREF(obj);
38560 return Py_BuildValue((char *)"");
38561 }
38562 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
38563 PyObject *resultobj = NULL;
38564 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38565 wxString *arg2 = 0 ;
38566 PyObject *arg3 = (PyObject *) NULL ;
38567 int result;
38568 bool temp2 = false ;
38569 PyObject * obj0 = 0 ;
38570 PyObject * obj1 = 0 ;
38571 PyObject * obj2 = 0 ;
38572 char *kwnames[] = {
38573 (char *) "self",(char *) "item",(char *) "clientData", NULL
38574 };
38575
38576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
38577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38578 if (SWIG_arg_fail(1)) SWIG_fail;
38579 {
38580 arg2 = wxString_in_helper(obj1);
38581 if (arg2 == NULL) SWIG_fail;
38582 temp2 = true;
38583 }
38584 if (obj2) {
38585 arg3 = obj2;
38586 }
38587 {
38588 PyThreadState* __tstate = wxPyBeginAllowThreads();
38589 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
38590
38591 wxPyEndAllowThreads(__tstate);
38592 if (PyErr_Occurred()) SWIG_fail;
38593 }
38594 {
38595 resultobj = SWIG_From_int(static_cast<int >(result));
38596 }
38597 {
38598 if (temp2)
38599 delete arg2;
38600 }
38601 return resultobj;
38602 fail:
38603 {
38604 if (temp2)
38605 delete arg2;
38606 }
38607 return NULL;
38608 }
38609
38610
38611 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
38612 PyObject *resultobj = NULL;
38613 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38614 wxArrayString *arg2 = 0 ;
38615 bool temp2 = false ;
38616 PyObject * obj0 = 0 ;
38617 PyObject * obj1 = 0 ;
38618 char *kwnames[] = {
38619 (char *) "self",(char *) "strings", NULL
38620 };
38621
38622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
38623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38624 if (SWIG_arg_fail(1)) SWIG_fail;
38625 {
38626 if (! PySequence_Check(obj1)) {
38627 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38628 SWIG_fail;
38629 }
38630 arg2 = new wxArrayString;
38631 temp2 = true;
38632 int i, len=PySequence_Length(obj1);
38633 for (i=0; i<len; i++) {
38634 PyObject* item = PySequence_GetItem(obj1, i);
38635 wxString* s = wxString_in_helper(item);
38636 if (PyErr_Occurred()) SWIG_fail;
38637 arg2->Add(*s);
38638 delete s;
38639 Py_DECREF(item);
38640 }
38641 }
38642 {
38643 PyThreadState* __tstate = wxPyBeginAllowThreads();
38644 (arg1)->Append((wxArrayString const &)*arg2);
38645
38646 wxPyEndAllowThreads(__tstate);
38647 if (PyErr_Occurred()) SWIG_fail;
38648 }
38649 Py_INCREF(Py_None); resultobj = Py_None;
38650 {
38651 if (temp2) delete arg2;
38652 }
38653 return resultobj;
38654 fail:
38655 {
38656 if (temp2) delete arg2;
38657 }
38658 return NULL;
38659 }
38660
38661
38662 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38663 PyObject *resultobj = NULL;
38664 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38665 wxString *arg2 = 0 ;
38666 int arg3 ;
38667 PyObject *arg4 = (PyObject *) NULL ;
38668 int result;
38669 bool temp2 = false ;
38670 PyObject * obj0 = 0 ;
38671 PyObject * obj1 = 0 ;
38672 PyObject * obj2 = 0 ;
38673 PyObject * obj3 = 0 ;
38674 char *kwnames[] = {
38675 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
38676 };
38677
38678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
38679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38680 if (SWIG_arg_fail(1)) SWIG_fail;
38681 {
38682 arg2 = wxString_in_helper(obj1);
38683 if (arg2 == NULL) SWIG_fail;
38684 temp2 = true;
38685 }
38686 {
38687 arg3 = static_cast<int >(SWIG_As_int(obj2));
38688 if (SWIG_arg_fail(3)) SWIG_fail;
38689 }
38690 if (obj3) {
38691 arg4 = obj3;
38692 }
38693 {
38694 PyThreadState* __tstate = wxPyBeginAllowThreads();
38695 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
38696
38697 wxPyEndAllowThreads(__tstate);
38698 if (PyErr_Occurred()) SWIG_fail;
38699 }
38700 {
38701 resultobj = SWIG_From_int(static_cast<int >(result));
38702 }
38703 {
38704 if (temp2)
38705 delete arg2;
38706 }
38707 return resultobj;
38708 fail:
38709 {
38710 if (temp2)
38711 delete arg2;
38712 }
38713 return NULL;
38714 }
38715
38716
38717 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
38718 PyObject *resultobj = NULL;
38719 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38720 PyObject * obj0 = 0 ;
38721 char *kwnames[] = {
38722 (char *) "self", NULL
38723 };
38724
38725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
38726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38727 if (SWIG_arg_fail(1)) SWIG_fail;
38728 {
38729 PyThreadState* __tstate = wxPyBeginAllowThreads();
38730 (arg1)->Clear();
38731
38732 wxPyEndAllowThreads(__tstate);
38733 if (PyErr_Occurred()) SWIG_fail;
38734 }
38735 Py_INCREF(Py_None); resultobj = Py_None;
38736 return resultobj;
38737 fail:
38738 return NULL;
38739 }
38740
38741
38742 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
38743 PyObject *resultobj = NULL;
38744 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38745 int arg2 ;
38746 PyObject * obj0 = 0 ;
38747 PyObject * obj1 = 0 ;
38748 char *kwnames[] = {
38749 (char *) "self",(char *) "n", NULL
38750 };
38751
38752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
38753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38754 if (SWIG_arg_fail(1)) SWIG_fail;
38755 {
38756 arg2 = static_cast<int >(SWIG_As_int(obj1));
38757 if (SWIG_arg_fail(2)) SWIG_fail;
38758 }
38759 {
38760 PyThreadState* __tstate = wxPyBeginAllowThreads();
38761 (arg1)->Delete(arg2);
38762
38763 wxPyEndAllowThreads(__tstate);
38764 if (PyErr_Occurred()) SWIG_fail;
38765 }
38766 Py_INCREF(Py_None); resultobj = Py_None;
38767 return resultobj;
38768 fail:
38769 return NULL;
38770 }
38771
38772
38773 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38774 PyObject *resultobj = NULL;
38775 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38776 int arg2 ;
38777 PyObject *result;
38778 PyObject * obj0 = 0 ;
38779 PyObject * obj1 = 0 ;
38780 char *kwnames[] = {
38781 (char *) "self",(char *) "n", NULL
38782 };
38783
38784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
38785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38786 if (SWIG_arg_fail(1)) SWIG_fail;
38787 {
38788 arg2 = static_cast<int >(SWIG_As_int(obj1));
38789 if (SWIG_arg_fail(2)) SWIG_fail;
38790 }
38791 {
38792 PyThreadState* __tstate = wxPyBeginAllowThreads();
38793 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
38794
38795 wxPyEndAllowThreads(__tstate);
38796 if (PyErr_Occurred()) SWIG_fail;
38797 }
38798 resultobj = result;
38799 return resultobj;
38800 fail:
38801 return NULL;
38802 }
38803
38804
38805 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38806 PyObject *resultobj = NULL;
38807 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38808 int arg2 ;
38809 PyObject *arg3 = (PyObject *) 0 ;
38810 PyObject * obj0 = 0 ;
38811 PyObject * obj1 = 0 ;
38812 PyObject * obj2 = 0 ;
38813 char *kwnames[] = {
38814 (char *) "self",(char *) "n",(char *) "clientData", NULL
38815 };
38816
38817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38819 if (SWIG_arg_fail(1)) SWIG_fail;
38820 {
38821 arg2 = static_cast<int >(SWIG_As_int(obj1));
38822 if (SWIG_arg_fail(2)) SWIG_fail;
38823 }
38824 arg3 = obj2;
38825 {
38826 PyThreadState* __tstate = wxPyBeginAllowThreads();
38827 wxItemContainer_SetClientData(arg1,arg2,arg3);
38828
38829 wxPyEndAllowThreads(__tstate);
38830 if (PyErr_Occurred()) SWIG_fail;
38831 }
38832 Py_INCREF(Py_None); resultobj = Py_None;
38833 return resultobj;
38834 fail:
38835 return NULL;
38836 }
38837
38838
38839 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38840 PyObject *resultobj = NULL;
38841 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38842 int result;
38843 PyObject * obj0 = 0 ;
38844 char *kwnames[] = {
38845 (char *) "self", NULL
38846 };
38847
38848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38850 if (SWIG_arg_fail(1)) SWIG_fail;
38851 {
38852 PyThreadState* __tstate = wxPyBeginAllowThreads();
38853 result = (int)((wxItemContainer const *)arg1)->GetCount();
38854
38855 wxPyEndAllowThreads(__tstate);
38856 if (PyErr_Occurred()) SWIG_fail;
38857 }
38858 {
38859 resultobj = SWIG_From_int(static_cast<int >(result));
38860 }
38861 return resultobj;
38862 fail:
38863 return NULL;
38864 }
38865
38866
38867 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38868 PyObject *resultobj = NULL;
38869 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38870 bool result;
38871 PyObject * obj0 = 0 ;
38872 char *kwnames[] = {
38873 (char *) "self", NULL
38874 };
38875
38876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38878 if (SWIG_arg_fail(1)) SWIG_fail;
38879 {
38880 PyThreadState* __tstate = wxPyBeginAllowThreads();
38881 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38882
38883 wxPyEndAllowThreads(__tstate);
38884 if (PyErr_Occurred()) SWIG_fail;
38885 }
38886 {
38887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38888 }
38889 return resultobj;
38890 fail:
38891 return NULL;
38892 }
38893
38894
38895 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38896 PyObject *resultobj = NULL;
38897 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38898 int arg2 ;
38899 wxString result;
38900 PyObject * obj0 = 0 ;
38901 PyObject * obj1 = 0 ;
38902 char *kwnames[] = {
38903 (char *) "self",(char *) "n", NULL
38904 };
38905
38906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38908 if (SWIG_arg_fail(1)) SWIG_fail;
38909 {
38910 arg2 = static_cast<int >(SWIG_As_int(obj1));
38911 if (SWIG_arg_fail(2)) SWIG_fail;
38912 }
38913 {
38914 PyThreadState* __tstate = wxPyBeginAllowThreads();
38915 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38916
38917 wxPyEndAllowThreads(__tstate);
38918 if (PyErr_Occurred()) SWIG_fail;
38919 }
38920 {
38921 #if wxUSE_UNICODE
38922 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38923 #else
38924 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38925 #endif
38926 }
38927 return resultobj;
38928 fail:
38929 return NULL;
38930 }
38931
38932
38933 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38934 PyObject *resultobj = NULL;
38935 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38936 wxArrayString result;
38937 PyObject * obj0 = 0 ;
38938 char *kwnames[] = {
38939 (char *) "self", NULL
38940 };
38941
38942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38944 if (SWIG_arg_fail(1)) SWIG_fail;
38945 {
38946 PyThreadState* __tstate = wxPyBeginAllowThreads();
38947 result = ((wxItemContainer const *)arg1)->GetStrings();
38948
38949 wxPyEndAllowThreads(__tstate);
38950 if (PyErr_Occurred()) SWIG_fail;
38951 }
38952 {
38953 resultobj = wxArrayString2PyList_helper(result);
38954 }
38955 return resultobj;
38956 fail:
38957 return NULL;
38958 }
38959
38960
38961 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38962 PyObject *resultobj = NULL;
38963 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38964 int arg2 ;
38965 wxString *arg3 = 0 ;
38966 bool temp3 = false ;
38967 PyObject * obj0 = 0 ;
38968 PyObject * obj1 = 0 ;
38969 PyObject * obj2 = 0 ;
38970 char *kwnames[] = {
38971 (char *) "self",(char *) "n",(char *) "s", NULL
38972 };
38973
38974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38976 if (SWIG_arg_fail(1)) SWIG_fail;
38977 {
38978 arg2 = static_cast<int >(SWIG_As_int(obj1));
38979 if (SWIG_arg_fail(2)) SWIG_fail;
38980 }
38981 {
38982 arg3 = wxString_in_helper(obj2);
38983 if (arg3 == NULL) SWIG_fail;
38984 temp3 = true;
38985 }
38986 {
38987 PyThreadState* __tstate = wxPyBeginAllowThreads();
38988 (arg1)->SetString(arg2,(wxString const &)*arg3);
38989
38990 wxPyEndAllowThreads(__tstate);
38991 if (PyErr_Occurred()) SWIG_fail;
38992 }
38993 Py_INCREF(Py_None); resultobj = Py_None;
38994 {
38995 if (temp3)
38996 delete arg3;
38997 }
38998 return resultobj;
38999 fail:
39000 {
39001 if (temp3)
39002 delete arg3;
39003 }
39004 return NULL;
39005 }
39006
39007
39008 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
39009 PyObject *resultobj = NULL;
39010 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39011 wxString *arg2 = 0 ;
39012 int result;
39013 bool temp2 = false ;
39014 PyObject * obj0 = 0 ;
39015 PyObject * obj1 = 0 ;
39016 char *kwnames[] = {
39017 (char *) "self",(char *) "s", NULL
39018 };
39019
39020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
39021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39022 if (SWIG_arg_fail(1)) SWIG_fail;
39023 {
39024 arg2 = wxString_in_helper(obj1);
39025 if (arg2 == NULL) SWIG_fail;
39026 temp2 = true;
39027 }
39028 {
39029 PyThreadState* __tstate = wxPyBeginAllowThreads();
39030 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
39031
39032 wxPyEndAllowThreads(__tstate);
39033 if (PyErr_Occurred()) SWIG_fail;
39034 }
39035 {
39036 resultobj = SWIG_From_int(static_cast<int >(result));
39037 }
39038 {
39039 if (temp2)
39040 delete arg2;
39041 }
39042 return resultobj;
39043 fail:
39044 {
39045 if (temp2)
39046 delete arg2;
39047 }
39048 return NULL;
39049 }
39050
39051
39052 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39053 PyObject *resultobj = NULL;
39054 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39055 int arg2 ;
39056 PyObject * obj0 = 0 ;
39057 PyObject * obj1 = 0 ;
39058 char *kwnames[] = {
39059 (char *) "self",(char *) "n", NULL
39060 };
39061
39062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
39063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39064 if (SWIG_arg_fail(1)) SWIG_fail;
39065 {
39066 arg2 = static_cast<int >(SWIG_As_int(obj1));
39067 if (SWIG_arg_fail(2)) SWIG_fail;
39068 }
39069 {
39070 PyThreadState* __tstate = wxPyBeginAllowThreads();
39071 (arg1)->SetSelection(arg2);
39072
39073 wxPyEndAllowThreads(__tstate);
39074 if (PyErr_Occurred()) SWIG_fail;
39075 }
39076 Py_INCREF(Py_None); resultobj = Py_None;
39077 return resultobj;
39078 fail:
39079 return NULL;
39080 }
39081
39082
39083 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39084 PyObject *resultobj = NULL;
39085 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39086 int result;
39087 PyObject * obj0 = 0 ;
39088 char *kwnames[] = {
39089 (char *) "self", NULL
39090 };
39091
39092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
39093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39094 if (SWIG_arg_fail(1)) SWIG_fail;
39095 {
39096 PyThreadState* __tstate = wxPyBeginAllowThreads();
39097 result = (int)((wxItemContainer const *)arg1)->GetSelection();
39098
39099 wxPyEndAllowThreads(__tstate);
39100 if (PyErr_Occurred()) SWIG_fail;
39101 }
39102 {
39103 resultobj = SWIG_From_int(static_cast<int >(result));
39104 }
39105 return resultobj;
39106 fail:
39107 return NULL;
39108 }
39109
39110
39111 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39112 PyObject *resultobj = NULL;
39113 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39114 wxString *arg2 = 0 ;
39115 bool result;
39116 bool temp2 = false ;
39117 PyObject * obj0 = 0 ;
39118 PyObject * obj1 = 0 ;
39119 char *kwnames[] = {
39120 (char *) "self",(char *) "s", NULL
39121 };
39122
39123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
39124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39125 if (SWIG_arg_fail(1)) SWIG_fail;
39126 {
39127 arg2 = wxString_in_helper(obj1);
39128 if (arg2 == NULL) SWIG_fail;
39129 temp2 = true;
39130 }
39131 {
39132 PyThreadState* __tstate = wxPyBeginAllowThreads();
39133 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
39134
39135 wxPyEndAllowThreads(__tstate);
39136 if (PyErr_Occurred()) SWIG_fail;
39137 }
39138 {
39139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39140 }
39141 {
39142 if (temp2)
39143 delete arg2;
39144 }
39145 return resultobj;
39146 fail:
39147 {
39148 if (temp2)
39149 delete arg2;
39150 }
39151 return NULL;
39152 }
39153
39154
39155 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39156 PyObject *resultobj = NULL;
39157 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39158 wxString result;
39159 PyObject * obj0 = 0 ;
39160 char *kwnames[] = {
39161 (char *) "self", NULL
39162 };
39163
39164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
39165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39166 if (SWIG_arg_fail(1)) SWIG_fail;
39167 {
39168 PyThreadState* __tstate = wxPyBeginAllowThreads();
39169 result = ((wxItemContainer const *)arg1)->GetStringSelection();
39170
39171 wxPyEndAllowThreads(__tstate);
39172 if (PyErr_Occurred()) SWIG_fail;
39173 }
39174 {
39175 #if wxUSE_UNICODE
39176 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39177 #else
39178 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39179 #endif
39180 }
39181 return resultobj;
39182 fail:
39183 return NULL;
39184 }
39185
39186
39187 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
39188 PyObject *resultobj = NULL;
39189 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39190 int arg2 ;
39191 PyObject * obj0 = 0 ;
39192 PyObject * obj1 = 0 ;
39193 char *kwnames[] = {
39194 (char *) "self",(char *) "n", NULL
39195 };
39196
39197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
39198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39199 if (SWIG_arg_fail(1)) SWIG_fail;
39200 {
39201 arg2 = static_cast<int >(SWIG_As_int(obj1));
39202 if (SWIG_arg_fail(2)) SWIG_fail;
39203 }
39204 {
39205 PyThreadState* __tstate = wxPyBeginAllowThreads();
39206 (arg1)->Select(arg2);
39207
39208 wxPyEndAllowThreads(__tstate);
39209 if (PyErr_Occurred()) SWIG_fail;
39210 }
39211 Py_INCREF(Py_None); resultobj = Py_None;
39212 return resultobj;
39213 fail:
39214 return NULL;
39215 }
39216
39217
39218 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
39219 PyObject *obj;
39220 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39221 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
39222 Py_INCREF(obj);
39223 return Py_BuildValue((char *)"");
39224 }
39225 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
39226 PyObject *obj;
39227 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39228 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
39229 Py_INCREF(obj);
39230 return Py_BuildValue((char *)"");
39231 }
39232 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
39233 PyObject *resultobj = NULL;
39234 wxSizerItem *result;
39235 char *kwnames[] = {
39236 NULL
39237 };
39238
39239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
39240 {
39241 PyThreadState* __tstate = wxPyBeginAllowThreads();
39242 result = (wxSizerItem *)new wxSizerItem();
39243
39244 wxPyEndAllowThreads(__tstate);
39245 if (PyErr_Occurred()) SWIG_fail;
39246 }
39247 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39248 return resultobj;
39249 fail:
39250 return NULL;
39251 }
39252
39253
39254 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39255 PyObject *resultobj = NULL;
39256 wxWindow *arg1 = (wxWindow *) 0 ;
39257 int arg2 ;
39258 int arg3 ;
39259 int arg4 ;
39260 PyObject *arg5 = (PyObject *) NULL ;
39261 wxSizerItem *result;
39262 PyObject * obj0 = 0 ;
39263 PyObject * obj1 = 0 ;
39264 PyObject * obj2 = 0 ;
39265 PyObject * obj3 = 0 ;
39266 PyObject * obj4 = 0 ;
39267 char *kwnames[] = {
39268 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39269 };
39270
39271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39273 if (SWIG_arg_fail(1)) SWIG_fail;
39274 {
39275 arg2 = static_cast<int >(SWIG_As_int(obj1));
39276 if (SWIG_arg_fail(2)) SWIG_fail;
39277 }
39278 {
39279 arg3 = static_cast<int >(SWIG_As_int(obj2));
39280 if (SWIG_arg_fail(3)) SWIG_fail;
39281 }
39282 {
39283 arg4 = static_cast<int >(SWIG_As_int(obj3));
39284 if (SWIG_arg_fail(4)) SWIG_fail;
39285 }
39286 if (obj4) {
39287 arg5 = obj4;
39288 }
39289 {
39290 PyThreadState* __tstate = wxPyBeginAllowThreads();
39291 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39292
39293 wxPyEndAllowThreads(__tstate);
39294 if (PyErr_Occurred()) SWIG_fail;
39295 }
39296 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39297 return resultobj;
39298 fail:
39299 return NULL;
39300 }
39301
39302
39303 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39304 PyObject *resultobj = NULL;
39305 int arg1 ;
39306 int arg2 ;
39307 int arg3 ;
39308 int arg4 ;
39309 int arg5 ;
39310 PyObject *arg6 = (PyObject *) NULL ;
39311 wxSizerItem *result;
39312 PyObject * obj0 = 0 ;
39313 PyObject * obj1 = 0 ;
39314 PyObject * obj2 = 0 ;
39315 PyObject * obj3 = 0 ;
39316 PyObject * obj4 = 0 ;
39317 PyObject * obj5 = 0 ;
39318 char *kwnames[] = {
39319 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39320 };
39321
39322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39323 {
39324 arg1 = static_cast<int >(SWIG_As_int(obj0));
39325 if (SWIG_arg_fail(1)) SWIG_fail;
39326 }
39327 {
39328 arg2 = static_cast<int >(SWIG_As_int(obj1));
39329 if (SWIG_arg_fail(2)) SWIG_fail;
39330 }
39331 {
39332 arg3 = static_cast<int >(SWIG_As_int(obj2));
39333 if (SWIG_arg_fail(3)) SWIG_fail;
39334 }
39335 {
39336 arg4 = static_cast<int >(SWIG_As_int(obj3));
39337 if (SWIG_arg_fail(4)) SWIG_fail;
39338 }
39339 {
39340 arg5 = static_cast<int >(SWIG_As_int(obj4));
39341 if (SWIG_arg_fail(5)) SWIG_fail;
39342 }
39343 if (obj5) {
39344 arg6 = obj5;
39345 }
39346 {
39347 PyThreadState* __tstate = wxPyBeginAllowThreads();
39348 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
39349
39350 wxPyEndAllowThreads(__tstate);
39351 if (PyErr_Occurred()) SWIG_fail;
39352 }
39353 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39354 return resultobj;
39355 fail:
39356 return NULL;
39357 }
39358
39359
39360 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39361 PyObject *resultobj = NULL;
39362 wxSizer *arg1 = (wxSizer *) 0 ;
39363 int arg2 ;
39364 int arg3 ;
39365 int arg4 ;
39366 PyObject *arg5 = (PyObject *) NULL ;
39367 wxSizerItem *result;
39368 PyObject * obj0 = 0 ;
39369 PyObject * obj1 = 0 ;
39370 PyObject * obj2 = 0 ;
39371 PyObject * obj3 = 0 ;
39372 PyObject * obj4 = 0 ;
39373 char *kwnames[] = {
39374 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39375 };
39376
39377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39379 if (SWIG_arg_fail(1)) SWIG_fail;
39380 {
39381 arg2 = static_cast<int >(SWIG_As_int(obj1));
39382 if (SWIG_arg_fail(2)) SWIG_fail;
39383 }
39384 {
39385 arg3 = static_cast<int >(SWIG_As_int(obj2));
39386 if (SWIG_arg_fail(3)) SWIG_fail;
39387 }
39388 {
39389 arg4 = static_cast<int >(SWIG_As_int(obj3));
39390 if (SWIG_arg_fail(4)) SWIG_fail;
39391 }
39392 if (obj4) {
39393 arg5 = obj4;
39394 }
39395 {
39396 PyThreadState* __tstate = wxPyBeginAllowThreads();
39397 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39398
39399 wxPyEndAllowThreads(__tstate);
39400 if (PyErr_Occurred()) SWIG_fail;
39401 }
39402 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39403 return resultobj;
39404 fail:
39405 return NULL;
39406 }
39407
39408
39409 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39410 PyObject *resultobj = NULL;
39411 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39412 PyObject * obj0 = 0 ;
39413 char *kwnames[] = {
39414 (char *) "self", NULL
39415 };
39416
39417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
39418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39419 if (SWIG_arg_fail(1)) SWIG_fail;
39420 {
39421 PyThreadState* __tstate = wxPyBeginAllowThreads();
39422 (arg1)->DeleteWindows();
39423
39424 wxPyEndAllowThreads(__tstate);
39425 if (PyErr_Occurred()) SWIG_fail;
39426 }
39427 Py_INCREF(Py_None); resultobj = Py_None;
39428 return resultobj;
39429 fail:
39430 return NULL;
39431 }
39432
39433
39434 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39435 PyObject *resultobj = NULL;
39436 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39437 PyObject * obj0 = 0 ;
39438 char *kwnames[] = {
39439 (char *) "self", NULL
39440 };
39441
39442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
39443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39444 if (SWIG_arg_fail(1)) SWIG_fail;
39445 {
39446 PyThreadState* __tstate = wxPyBeginAllowThreads();
39447 (arg1)->DetachSizer();
39448
39449 wxPyEndAllowThreads(__tstate);
39450 if (PyErr_Occurred()) SWIG_fail;
39451 }
39452 Py_INCREF(Py_None); resultobj = Py_None;
39453 return resultobj;
39454 fail:
39455 return NULL;
39456 }
39457
39458
39459 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39460 PyObject *resultobj = NULL;
39461 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39462 wxSize result;
39463 PyObject * obj0 = 0 ;
39464 char *kwnames[] = {
39465 (char *) "self", NULL
39466 };
39467
39468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
39469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39470 if (SWIG_arg_fail(1)) SWIG_fail;
39471 {
39472 PyThreadState* __tstate = wxPyBeginAllowThreads();
39473 result = (arg1)->GetSize();
39474
39475 wxPyEndAllowThreads(__tstate);
39476 if (PyErr_Occurred()) SWIG_fail;
39477 }
39478 {
39479 wxSize * resultptr;
39480 resultptr = new wxSize(static_cast<wxSize & >(result));
39481 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39482 }
39483 return resultobj;
39484 fail:
39485 return NULL;
39486 }
39487
39488
39489 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39490 PyObject *resultobj = NULL;
39491 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39492 wxSize result;
39493 PyObject * obj0 = 0 ;
39494 char *kwnames[] = {
39495 (char *) "self", NULL
39496 };
39497
39498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
39499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39500 if (SWIG_arg_fail(1)) SWIG_fail;
39501 {
39502 PyThreadState* __tstate = wxPyBeginAllowThreads();
39503 result = (arg1)->CalcMin();
39504
39505 wxPyEndAllowThreads(__tstate);
39506 if (PyErr_Occurred()) SWIG_fail;
39507 }
39508 {
39509 wxSize * resultptr;
39510 resultptr = new wxSize(static_cast<wxSize & >(result));
39511 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39512 }
39513 return resultobj;
39514 fail:
39515 return NULL;
39516 }
39517
39518
39519 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39520 PyObject *resultobj = NULL;
39521 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39522 wxPoint arg2 ;
39523 wxSize arg3 ;
39524 PyObject * obj0 = 0 ;
39525 PyObject * obj1 = 0 ;
39526 PyObject * obj2 = 0 ;
39527 char *kwnames[] = {
39528 (char *) "self",(char *) "pos",(char *) "size", NULL
39529 };
39530
39531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
39532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39533 if (SWIG_arg_fail(1)) SWIG_fail;
39534 {
39535 wxPoint * argp;
39536 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
39537 if (SWIG_arg_fail(2)) SWIG_fail;
39538 if (argp == NULL) {
39539 SWIG_null_ref("wxPoint");
39540 }
39541 if (SWIG_arg_fail(2)) SWIG_fail;
39542 arg2 = *argp;
39543 }
39544 {
39545 wxSize * argp;
39546 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
39547 if (SWIG_arg_fail(3)) SWIG_fail;
39548 if (argp == NULL) {
39549 SWIG_null_ref("wxSize");
39550 }
39551 if (SWIG_arg_fail(3)) SWIG_fail;
39552 arg3 = *argp;
39553 }
39554 {
39555 PyThreadState* __tstate = wxPyBeginAllowThreads();
39556 (arg1)->SetDimension(arg2,arg3);
39557
39558 wxPyEndAllowThreads(__tstate);
39559 if (PyErr_Occurred()) SWIG_fail;
39560 }
39561 Py_INCREF(Py_None); resultobj = Py_None;
39562 return resultobj;
39563 fail:
39564 return NULL;
39565 }
39566
39567
39568 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39569 PyObject *resultobj = NULL;
39570 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39571 wxSize result;
39572 PyObject * obj0 = 0 ;
39573 char *kwnames[] = {
39574 (char *) "self", NULL
39575 };
39576
39577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
39578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39579 if (SWIG_arg_fail(1)) SWIG_fail;
39580 {
39581 PyThreadState* __tstate = wxPyBeginAllowThreads();
39582 result = (arg1)->GetMinSize();
39583
39584 wxPyEndAllowThreads(__tstate);
39585 if (PyErr_Occurred()) SWIG_fail;
39586 }
39587 {
39588 wxSize * resultptr;
39589 resultptr = new wxSize(static_cast<wxSize & >(result));
39590 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39591 }
39592 return resultobj;
39593 fail:
39594 return NULL;
39595 }
39596
39597
39598 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39599 PyObject *resultobj = NULL;
39600 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39601 wxSize result;
39602 PyObject * obj0 = 0 ;
39603 char *kwnames[] = {
39604 (char *) "self", NULL
39605 };
39606
39607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
39608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39609 if (SWIG_arg_fail(1)) SWIG_fail;
39610 {
39611 PyThreadState* __tstate = wxPyBeginAllowThreads();
39612 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
39613
39614 wxPyEndAllowThreads(__tstate);
39615 if (PyErr_Occurred()) SWIG_fail;
39616 }
39617 {
39618 wxSize * resultptr;
39619 resultptr = new wxSize(static_cast<wxSize & >(result));
39620 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39621 }
39622 return resultobj;
39623 fail:
39624 return NULL;
39625 }
39626
39627
39628 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
39629 PyObject *resultobj = NULL;
39630 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39631 int arg2 ;
39632 int arg3 ;
39633 PyObject * obj0 = 0 ;
39634 PyObject * obj1 = 0 ;
39635 PyObject * obj2 = 0 ;
39636 char *kwnames[] = {
39637 (char *) "self",(char *) "x",(char *) "y", NULL
39638 };
39639
39640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39642 if (SWIG_arg_fail(1)) SWIG_fail;
39643 {
39644 arg2 = static_cast<int >(SWIG_As_int(obj1));
39645 if (SWIG_arg_fail(2)) SWIG_fail;
39646 }
39647 {
39648 arg3 = static_cast<int >(SWIG_As_int(obj2));
39649 if (SWIG_arg_fail(3)) SWIG_fail;
39650 }
39651 {
39652 PyThreadState* __tstate = wxPyBeginAllowThreads();
39653 (arg1)->SetInitSize(arg2,arg3);
39654
39655 wxPyEndAllowThreads(__tstate);
39656 if (PyErr_Occurred()) SWIG_fail;
39657 }
39658 Py_INCREF(Py_None); resultobj = Py_None;
39659 return resultobj;
39660 fail:
39661 return NULL;
39662 }
39663
39664
39665 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
39666 PyObject *resultobj = NULL;
39667 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39668 int arg2 ;
39669 int arg3 ;
39670 PyObject * obj0 = 0 ;
39671 PyObject * obj1 = 0 ;
39672 PyObject * obj2 = 0 ;
39673 char *kwnames[] = {
39674 (char *) "self",(char *) "width",(char *) "height", NULL
39675 };
39676
39677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
39678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39679 if (SWIG_arg_fail(1)) SWIG_fail;
39680 {
39681 arg2 = static_cast<int >(SWIG_As_int(obj1));
39682 if (SWIG_arg_fail(2)) SWIG_fail;
39683 }
39684 {
39685 arg3 = static_cast<int >(SWIG_As_int(obj2));
39686 if (SWIG_arg_fail(3)) SWIG_fail;
39687 }
39688 {
39689 PyThreadState* __tstate = wxPyBeginAllowThreads();
39690 (arg1)->SetRatio(arg2,arg3);
39691
39692 wxPyEndAllowThreads(__tstate);
39693 if (PyErr_Occurred()) SWIG_fail;
39694 }
39695 Py_INCREF(Py_None); resultobj = Py_None;
39696 return resultobj;
39697 fail:
39698 return NULL;
39699 }
39700
39701
39702 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
39703 PyObject *resultobj = NULL;
39704 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39705 wxSize *arg2 = 0 ;
39706 wxSize temp2 ;
39707 PyObject * obj0 = 0 ;
39708 PyObject * obj1 = 0 ;
39709 char *kwnames[] = {
39710 (char *) "self",(char *) "size", NULL
39711 };
39712
39713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
39714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39715 if (SWIG_arg_fail(1)) SWIG_fail;
39716 {
39717 arg2 = &temp2;
39718 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39719 }
39720 {
39721 PyThreadState* __tstate = wxPyBeginAllowThreads();
39722 (arg1)->SetRatio((wxSize const &)*arg2);
39723
39724 wxPyEndAllowThreads(__tstate);
39725 if (PyErr_Occurred()) SWIG_fail;
39726 }
39727 Py_INCREF(Py_None); resultobj = Py_None;
39728 return resultobj;
39729 fail:
39730 return NULL;
39731 }
39732
39733
39734 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39735 PyObject *resultobj = NULL;
39736 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39737 float arg2 ;
39738 PyObject * obj0 = 0 ;
39739 PyObject * obj1 = 0 ;
39740 char *kwnames[] = {
39741 (char *) "self",(char *) "ratio", NULL
39742 };
39743
39744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
39745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39746 if (SWIG_arg_fail(1)) SWIG_fail;
39747 {
39748 arg2 = static_cast<float >(SWIG_As_float(obj1));
39749 if (SWIG_arg_fail(2)) SWIG_fail;
39750 }
39751 {
39752 PyThreadState* __tstate = wxPyBeginAllowThreads();
39753 (arg1)->SetRatio(arg2);
39754
39755 wxPyEndAllowThreads(__tstate);
39756 if (PyErr_Occurred()) SWIG_fail;
39757 }
39758 Py_INCREF(Py_None); resultobj = Py_None;
39759 return resultobj;
39760 fail:
39761 return NULL;
39762 }
39763
39764
39765 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39766 PyObject *resultobj = NULL;
39767 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39768 float result;
39769 PyObject * obj0 = 0 ;
39770 char *kwnames[] = {
39771 (char *) "self", NULL
39772 };
39773
39774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
39775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39776 if (SWIG_arg_fail(1)) SWIG_fail;
39777 {
39778 PyThreadState* __tstate = wxPyBeginAllowThreads();
39779 result = (float)(arg1)->GetRatio();
39780
39781 wxPyEndAllowThreads(__tstate);
39782 if (PyErr_Occurred()) SWIG_fail;
39783 }
39784 {
39785 resultobj = SWIG_From_float(static_cast<float >(result));
39786 }
39787 return resultobj;
39788 fail:
39789 return NULL;
39790 }
39791
39792
39793 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
39794 PyObject *resultobj = NULL;
39795 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39796 wxRect result;
39797 PyObject * obj0 = 0 ;
39798 char *kwnames[] = {
39799 (char *) "self", NULL
39800 };
39801
39802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
39803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39804 if (SWIG_arg_fail(1)) SWIG_fail;
39805 {
39806 PyThreadState* __tstate = wxPyBeginAllowThreads();
39807 result = (arg1)->GetRect();
39808
39809 wxPyEndAllowThreads(__tstate);
39810 if (PyErr_Occurred()) SWIG_fail;
39811 }
39812 {
39813 wxRect * resultptr;
39814 resultptr = new wxRect(static_cast<wxRect & >(result));
39815 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39816 }
39817 return resultobj;
39818 fail:
39819 return NULL;
39820 }
39821
39822
39823 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39824 PyObject *resultobj = NULL;
39825 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39826 bool result;
39827 PyObject * obj0 = 0 ;
39828 char *kwnames[] = {
39829 (char *) "self", NULL
39830 };
39831
39832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39834 if (SWIG_arg_fail(1)) SWIG_fail;
39835 {
39836 PyThreadState* __tstate = wxPyBeginAllowThreads();
39837 result = (bool)(arg1)->IsWindow();
39838
39839 wxPyEndAllowThreads(__tstate);
39840 if (PyErr_Occurred()) SWIG_fail;
39841 }
39842 {
39843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39844 }
39845 return resultobj;
39846 fail:
39847 return NULL;
39848 }
39849
39850
39851 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39852 PyObject *resultobj = NULL;
39853 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39854 bool result;
39855 PyObject * obj0 = 0 ;
39856 char *kwnames[] = {
39857 (char *) "self", NULL
39858 };
39859
39860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39862 if (SWIG_arg_fail(1)) SWIG_fail;
39863 {
39864 PyThreadState* __tstate = wxPyBeginAllowThreads();
39865 result = (bool)(arg1)->IsSizer();
39866
39867 wxPyEndAllowThreads(__tstate);
39868 if (PyErr_Occurred()) SWIG_fail;
39869 }
39870 {
39871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39872 }
39873 return resultobj;
39874 fail:
39875 return NULL;
39876 }
39877
39878
39879 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39880 PyObject *resultobj = NULL;
39881 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39882 bool result;
39883 PyObject * obj0 = 0 ;
39884 char *kwnames[] = {
39885 (char *) "self", NULL
39886 };
39887
39888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39890 if (SWIG_arg_fail(1)) SWIG_fail;
39891 {
39892 PyThreadState* __tstate = wxPyBeginAllowThreads();
39893 result = (bool)(arg1)->IsSpacer();
39894
39895 wxPyEndAllowThreads(__tstate);
39896 if (PyErr_Occurred()) SWIG_fail;
39897 }
39898 {
39899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39900 }
39901 return resultobj;
39902 fail:
39903 return NULL;
39904 }
39905
39906
39907 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39908 PyObject *resultobj = NULL;
39909 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39910 int arg2 ;
39911 PyObject * obj0 = 0 ;
39912 PyObject * obj1 = 0 ;
39913 char *kwnames[] = {
39914 (char *) "self",(char *) "proportion", NULL
39915 };
39916
39917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39919 if (SWIG_arg_fail(1)) SWIG_fail;
39920 {
39921 arg2 = static_cast<int >(SWIG_As_int(obj1));
39922 if (SWIG_arg_fail(2)) SWIG_fail;
39923 }
39924 {
39925 PyThreadState* __tstate = wxPyBeginAllowThreads();
39926 (arg1)->SetProportion(arg2);
39927
39928 wxPyEndAllowThreads(__tstate);
39929 if (PyErr_Occurred()) SWIG_fail;
39930 }
39931 Py_INCREF(Py_None); resultobj = Py_None;
39932 return resultobj;
39933 fail:
39934 return NULL;
39935 }
39936
39937
39938 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39939 PyObject *resultobj = NULL;
39940 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39941 int result;
39942 PyObject * obj0 = 0 ;
39943 char *kwnames[] = {
39944 (char *) "self", NULL
39945 };
39946
39947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39949 if (SWIG_arg_fail(1)) SWIG_fail;
39950 {
39951 PyThreadState* __tstate = wxPyBeginAllowThreads();
39952 result = (int)(arg1)->GetProportion();
39953
39954 wxPyEndAllowThreads(__tstate);
39955 if (PyErr_Occurred()) SWIG_fail;
39956 }
39957 {
39958 resultobj = SWIG_From_int(static_cast<int >(result));
39959 }
39960 return resultobj;
39961 fail:
39962 return NULL;
39963 }
39964
39965
39966 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39967 PyObject *resultobj = NULL;
39968 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39969 int arg2 ;
39970 PyObject * obj0 = 0 ;
39971 PyObject * obj1 = 0 ;
39972 char *kwnames[] = {
39973 (char *) "self",(char *) "flag", NULL
39974 };
39975
39976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39978 if (SWIG_arg_fail(1)) SWIG_fail;
39979 {
39980 arg2 = static_cast<int >(SWIG_As_int(obj1));
39981 if (SWIG_arg_fail(2)) SWIG_fail;
39982 }
39983 {
39984 PyThreadState* __tstate = wxPyBeginAllowThreads();
39985 (arg1)->SetFlag(arg2);
39986
39987 wxPyEndAllowThreads(__tstate);
39988 if (PyErr_Occurred()) SWIG_fail;
39989 }
39990 Py_INCREF(Py_None); resultobj = Py_None;
39991 return resultobj;
39992 fail:
39993 return NULL;
39994 }
39995
39996
39997 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39998 PyObject *resultobj = NULL;
39999 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40000 int result;
40001 PyObject * obj0 = 0 ;
40002 char *kwnames[] = {
40003 (char *) "self", NULL
40004 };
40005
40006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
40007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40008 if (SWIG_arg_fail(1)) SWIG_fail;
40009 {
40010 PyThreadState* __tstate = wxPyBeginAllowThreads();
40011 result = (int)(arg1)->GetFlag();
40012
40013 wxPyEndAllowThreads(__tstate);
40014 if (PyErr_Occurred()) SWIG_fail;
40015 }
40016 {
40017 resultobj = SWIG_From_int(static_cast<int >(result));
40018 }
40019 return resultobj;
40020 fail:
40021 return NULL;
40022 }
40023
40024
40025 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
40026 PyObject *resultobj = NULL;
40027 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40028 int arg2 ;
40029 PyObject * obj0 = 0 ;
40030 PyObject * obj1 = 0 ;
40031 char *kwnames[] = {
40032 (char *) "self",(char *) "border", NULL
40033 };
40034
40035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
40036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40037 if (SWIG_arg_fail(1)) SWIG_fail;
40038 {
40039 arg2 = static_cast<int >(SWIG_As_int(obj1));
40040 if (SWIG_arg_fail(2)) SWIG_fail;
40041 }
40042 {
40043 PyThreadState* __tstate = wxPyBeginAllowThreads();
40044 (arg1)->SetBorder(arg2);
40045
40046 wxPyEndAllowThreads(__tstate);
40047 if (PyErr_Occurred()) SWIG_fail;
40048 }
40049 Py_INCREF(Py_None); resultobj = Py_None;
40050 return resultobj;
40051 fail:
40052 return NULL;
40053 }
40054
40055
40056 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
40057 PyObject *resultobj = NULL;
40058 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40059 int result;
40060 PyObject * obj0 = 0 ;
40061 char *kwnames[] = {
40062 (char *) "self", NULL
40063 };
40064
40065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
40066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40067 if (SWIG_arg_fail(1)) SWIG_fail;
40068 {
40069 PyThreadState* __tstate = wxPyBeginAllowThreads();
40070 result = (int)(arg1)->GetBorder();
40071
40072 wxPyEndAllowThreads(__tstate);
40073 if (PyErr_Occurred()) SWIG_fail;
40074 }
40075 {
40076 resultobj = SWIG_From_int(static_cast<int >(result));
40077 }
40078 return resultobj;
40079 fail:
40080 return NULL;
40081 }
40082
40083
40084 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40085 PyObject *resultobj = NULL;
40086 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40087 wxWindow *result;
40088 PyObject * obj0 = 0 ;
40089 char *kwnames[] = {
40090 (char *) "self", NULL
40091 };
40092
40093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
40094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40095 if (SWIG_arg_fail(1)) SWIG_fail;
40096 {
40097 PyThreadState* __tstate = wxPyBeginAllowThreads();
40098 result = (wxWindow *)(arg1)->GetWindow();
40099
40100 wxPyEndAllowThreads(__tstate);
40101 if (PyErr_Occurred()) SWIG_fail;
40102 }
40103 {
40104 resultobj = wxPyMake_wxObject(result, 0);
40105 }
40106 return resultobj;
40107 fail:
40108 return NULL;
40109 }
40110
40111
40112 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40113 PyObject *resultobj = NULL;
40114 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40115 wxWindow *arg2 = (wxWindow *) 0 ;
40116 PyObject * obj0 = 0 ;
40117 PyObject * obj1 = 0 ;
40118 char *kwnames[] = {
40119 (char *) "self",(char *) "window", NULL
40120 };
40121
40122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
40123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40124 if (SWIG_arg_fail(1)) SWIG_fail;
40125 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40126 if (SWIG_arg_fail(2)) SWIG_fail;
40127 {
40128 PyThreadState* __tstate = wxPyBeginAllowThreads();
40129 (arg1)->SetWindow(arg2);
40130
40131 wxPyEndAllowThreads(__tstate);
40132 if (PyErr_Occurred()) SWIG_fail;
40133 }
40134 Py_INCREF(Py_None); resultobj = Py_None;
40135 return resultobj;
40136 fail:
40137 return NULL;
40138 }
40139
40140
40141 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40142 PyObject *resultobj = NULL;
40143 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40144 wxSizer *result;
40145 PyObject * obj0 = 0 ;
40146 char *kwnames[] = {
40147 (char *) "self", NULL
40148 };
40149
40150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
40151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40152 if (SWIG_arg_fail(1)) SWIG_fail;
40153 {
40154 PyThreadState* __tstate = wxPyBeginAllowThreads();
40155 result = (wxSizer *)(arg1)->GetSizer();
40156
40157 wxPyEndAllowThreads(__tstate);
40158 if (PyErr_Occurred()) SWIG_fail;
40159 }
40160 {
40161 resultobj = wxPyMake_wxObject(result, 0);
40162 }
40163 return resultobj;
40164 fail:
40165 return NULL;
40166 }
40167
40168
40169 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40170 PyObject *resultobj = NULL;
40171 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40172 wxSizer *arg2 = (wxSizer *) 0 ;
40173 PyObject * obj0 = 0 ;
40174 PyObject * obj1 = 0 ;
40175 char *kwnames[] = {
40176 (char *) "self",(char *) "sizer", NULL
40177 };
40178
40179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
40180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40181 if (SWIG_arg_fail(1)) SWIG_fail;
40182 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40183 if (SWIG_arg_fail(2)) SWIG_fail;
40184 {
40185 PyThreadState* __tstate = wxPyBeginAllowThreads();
40186 (arg1)->SetSizer(arg2);
40187
40188 wxPyEndAllowThreads(__tstate);
40189 if (PyErr_Occurred()) SWIG_fail;
40190 }
40191 Py_INCREF(Py_None); resultobj = Py_None;
40192 return resultobj;
40193 fail:
40194 return NULL;
40195 }
40196
40197
40198 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40199 PyObject *resultobj = NULL;
40200 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40201 wxSize *result;
40202 PyObject * obj0 = 0 ;
40203 char *kwnames[] = {
40204 (char *) "self", NULL
40205 };
40206
40207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
40208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40209 if (SWIG_arg_fail(1)) SWIG_fail;
40210 {
40211 PyThreadState* __tstate = wxPyBeginAllowThreads();
40212 {
40213 wxSize const &_result_ref = (arg1)->GetSpacer();
40214 result = (wxSize *) &_result_ref;
40215 }
40216
40217 wxPyEndAllowThreads(__tstate);
40218 if (PyErr_Occurred()) SWIG_fail;
40219 }
40220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
40221 return resultobj;
40222 fail:
40223 return NULL;
40224 }
40225
40226
40227 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40228 PyObject *resultobj = NULL;
40229 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40230 wxSize *arg2 = 0 ;
40231 wxSize temp2 ;
40232 PyObject * obj0 = 0 ;
40233 PyObject * obj1 = 0 ;
40234 char *kwnames[] = {
40235 (char *) "self",(char *) "size", NULL
40236 };
40237
40238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
40239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40240 if (SWIG_arg_fail(1)) SWIG_fail;
40241 {
40242 arg2 = &temp2;
40243 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40244 }
40245 {
40246 PyThreadState* __tstate = wxPyBeginAllowThreads();
40247 (arg1)->SetSpacer((wxSize const &)*arg2);
40248
40249 wxPyEndAllowThreads(__tstate);
40250 if (PyErr_Occurred()) SWIG_fail;
40251 }
40252 Py_INCREF(Py_None); resultobj = Py_None;
40253 return resultobj;
40254 fail:
40255 return NULL;
40256 }
40257
40258
40259 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40260 PyObject *resultobj = NULL;
40261 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40262 bool arg2 ;
40263 PyObject * obj0 = 0 ;
40264 PyObject * obj1 = 0 ;
40265 char *kwnames[] = {
40266 (char *) "self",(char *) "show", NULL
40267 };
40268
40269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
40270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40271 if (SWIG_arg_fail(1)) SWIG_fail;
40272 {
40273 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
40274 if (SWIG_arg_fail(2)) SWIG_fail;
40275 }
40276 {
40277 PyThreadState* __tstate = wxPyBeginAllowThreads();
40278 (arg1)->Show(arg2);
40279
40280 wxPyEndAllowThreads(__tstate);
40281 if (PyErr_Occurred()) SWIG_fail;
40282 }
40283 Py_INCREF(Py_None); resultobj = Py_None;
40284 return resultobj;
40285 fail:
40286 return NULL;
40287 }
40288
40289
40290 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40291 PyObject *resultobj = NULL;
40292 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40293 bool result;
40294 PyObject * obj0 = 0 ;
40295 char *kwnames[] = {
40296 (char *) "self", NULL
40297 };
40298
40299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
40300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40301 if (SWIG_arg_fail(1)) SWIG_fail;
40302 {
40303 PyThreadState* __tstate = wxPyBeginAllowThreads();
40304 result = (bool)(arg1)->IsShown();
40305
40306 wxPyEndAllowThreads(__tstate);
40307 if (PyErr_Occurred()) SWIG_fail;
40308 }
40309 {
40310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40311 }
40312 return resultobj;
40313 fail:
40314 return NULL;
40315 }
40316
40317
40318 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40319 PyObject *resultobj = NULL;
40320 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40321 wxPoint result;
40322 PyObject * obj0 = 0 ;
40323 char *kwnames[] = {
40324 (char *) "self", NULL
40325 };
40326
40327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
40328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40329 if (SWIG_arg_fail(1)) SWIG_fail;
40330 {
40331 PyThreadState* __tstate = wxPyBeginAllowThreads();
40332 result = (arg1)->GetPosition();
40333
40334 wxPyEndAllowThreads(__tstate);
40335 if (PyErr_Occurred()) SWIG_fail;
40336 }
40337 {
40338 wxPoint * resultptr;
40339 resultptr = new wxPoint(static_cast<wxPoint & >(result));
40340 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40341 }
40342 return resultobj;
40343 fail:
40344 return NULL;
40345 }
40346
40347
40348 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40349 PyObject *resultobj = NULL;
40350 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40351 PyObject *result;
40352 PyObject * obj0 = 0 ;
40353 char *kwnames[] = {
40354 (char *) "self", NULL
40355 };
40356
40357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
40358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40359 if (SWIG_arg_fail(1)) SWIG_fail;
40360 {
40361 PyThreadState* __tstate = wxPyBeginAllowThreads();
40362 result = (PyObject *)wxSizerItem_GetUserData(arg1);
40363
40364 wxPyEndAllowThreads(__tstate);
40365 if (PyErr_Occurred()) SWIG_fail;
40366 }
40367 resultobj = result;
40368 return resultobj;
40369 fail:
40370 return NULL;
40371 }
40372
40373
40374 static PyObject *_wrap_SizerItem_SetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40375 PyObject *resultobj = NULL;
40376 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40377 PyObject *arg2 = (PyObject *) 0 ;
40378 PyObject * obj0 = 0 ;
40379 PyObject * obj1 = 0 ;
40380 char *kwnames[] = {
40381 (char *) "self",(char *) "userData", NULL
40382 };
40383
40384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) goto fail;
40385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40386 if (SWIG_arg_fail(1)) SWIG_fail;
40387 arg2 = obj1;
40388 {
40389 PyThreadState* __tstate = wxPyBeginAllowThreads();
40390 wxSizerItem_SetUserData(arg1,arg2);
40391
40392 wxPyEndAllowThreads(__tstate);
40393 if (PyErr_Occurred()) SWIG_fail;
40394 }
40395 Py_INCREF(Py_None); resultobj = Py_None;
40396 return resultobj;
40397 fail:
40398 return NULL;
40399 }
40400
40401
40402 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
40403 PyObject *obj;
40404 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40405 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
40406 Py_INCREF(obj);
40407 return Py_BuildValue((char *)"");
40408 }
40409 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40410 PyObject *resultobj = NULL;
40411 wxSizer *arg1 = (wxSizer *) 0 ;
40412 PyObject *arg2 = (PyObject *) 0 ;
40413 PyObject * obj0 = 0 ;
40414 PyObject * obj1 = 0 ;
40415 char *kwnames[] = {
40416 (char *) "self",(char *) "_self", NULL
40417 };
40418
40419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
40420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40421 if (SWIG_arg_fail(1)) SWIG_fail;
40422 arg2 = obj1;
40423 {
40424 PyThreadState* __tstate = wxPyBeginAllowThreads();
40425 wxSizer__setOORInfo(arg1,arg2);
40426
40427 wxPyEndAllowThreads(__tstate);
40428 if (PyErr_Occurred()) SWIG_fail;
40429 }
40430 Py_INCREF(Py_None); resultobj = Py_None;
40431 return resultobj;
40432 fail:
40433 return NULL;
40434 }
40435
40436
40437 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
40438 PyObject *resultobj = NULL;
40439 wxSizer *arg1 = (wxSizer *) 0 ;
40440 PyObject *arg2 = (PyObject *) 0 ;
40441 int arg3 = (int) 0 ;
40442 int arg4 = (int) 0 ;
40443 int arg5 = (int) 0 ;
40444 PyObject *arg6 = (PyObject *) NULL ;
40445 wxSizerItem *result;
40446 PyObject * obj0 = 0 ;
40447 PyObject * obj1 = 0 ;
40448 PyObject * obj2 = 0 ;
40449 PyObject * obj3 = 0 ;
40450 PyObject * obj4 = 0 ;
40451 PyObject * obj5 = 0 ;
40452 char *kwnames[] = {
40453 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40454 };
40455
40456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40458 if (SWIG_arg_fail(1)) SWIG_fail;
40459 arg2 = obj1;
40460 if (obj2) {
40461 {
40462 arg3 = static_cast<int >(SWIG_As_int(obj2));
40463 if (SWIG_arg_fail(3)) SWIG_fail;
40464 }
40465 }
40466 if (obj3) {
40467 {
40468 arg4 = static_cast<int >(SWIG_As_int(obj3));
40469 if (SWIG_arg_fail(4)) SWIG_fail;
40470 }
40471 }
40472 if (obj4) {
40473 {
40474 arg5 = static_cast<int >(SWIG_As_int(obj4));
40475 if (SWIG_arg_fail(5)) SWIG_fail;
40476 }
40477 }
40478 if (obj5) {
40479 arg6 = obj5;
40480 }
40481 {
40482 PyThreadState* __tstate = wxPyBeginAllowThreads();
40483 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
40484
40485 wxPyEndAllowThreads(__tstate);
40486 if (PyErr_Occurred()) SWIG_fail;
40487 }
40488 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40489 return resultobj;
40490 fail:
40491 return NULL;
40492 }
40493
40494
40495 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
40496 PyObject *resultobj = NULL;
40497 wxSizer *arg1 = (wxSizer *) 0 ;
40498 int arg2 ;
40499 PyObject *arg3 = (PyObject *) 0 ;
40500 int arg4 = (int) 0 ;
40501 int arg5 = (int) 0 ;
40502 int arg6 = (int) 0 ;
40503 PyObject *arg7 = (PyObject *) NULL ;
40504 wxSizerItem *result;
40505 PyObject * obj0 = 0 ;
40506 PyObject * obj1 = 0 ;
40507 PyObject * obj2 = 0 ;
40508 PyObject * obj3 = 0 ;
40509 PyObject * obj4 = 0 ;
40510 PyObject * obj5 = 0 ;
40511 PyObject * obj6 = 0 ;
40512 char *kwnames[] = {
40513 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40514 };
40515
40516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
40517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40518 if (SWIG_arg_fail(1)) SWIG_fail;
40519 {
40520 arg2 = static_cast<int >(SWIG_As_int(obj1));
40521 if (SWIG_arg_fail(2)) SWIG_fail;
40522 }
40523 arg3 = obj2;
40524 if (obj3) {
40525 {
40526 arg4 = static_cast<int >(SWIG_As_int(obj3));
40527 if (SWIG_arg_fail(4)) SWIG_fail;
40528 }
40529 }
40530 if (obj4) {
40531 {
40532 arg5 = static_cast<int >(SWIG_As_int(obj4));
40533 if (SWIG_arg_fail(5)) SWIG_fail;
40534 }
40535 }
40536 if (obj5) {
40537 {
40538 arg6 = static_cast<int >(SWIG_As_int(obj5));
40539 if (SWIG_arg_fail(6)) SWIG_fail;
40540 }
40541 }
40542 if (obj6) {
40543 arg7 = obj6;
40544 }
40545 {
40546 PyThreadState* __tstate = wxPyBeginAllowThreads();
40547 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
40548
40549 wxPyEndAllowThreads(__tstate);
40550 if (PyErr_Occurred()) SWIG_fail;
40551 }
40552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40553 return resultobj;
40554 fail:
40555 return NULL;
40556 }
40557
40558
40559 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
40560 PyObject *resultobj = NULL;
40561 wxSizer *arg1 = (wxSizer *) 0 ;
40562 PyObject *arg2 = (PyObject *) 0 ;
40563 int arg3 = (int) 0 ;
40564 int arg4 = (int) 0 ;
40565 int arg5 = (int) 0 ;
40566 PyObject *arg6 = (PyObject *) NULL ;
40567 wxSizerItem *result;
40568 PyObject * obj0 = 0 ;
40569 PyObject * obj1 = 0 ;
40570 PyObject * obj2 = 0 ;
40571 PyObject * obj3 = 0 ;
40572 PyObject * obj4 = 0 ;
40573 PyObject * obj5 = 0 ;
40574 char *kwnames[] = {
40575 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40576 };
40577
40578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40580 if (SWIG_arg_fail(1)) SWIG_fail;
40581 arg2 = obj1;
40582 if (obj2) {
40583 {
40584 arg3 = static_cast<int >(SWIG_As_int(obj2));
40585 if (SWIG_arg_fail(3)) SWIG_fail;
40586 }
40587 }
40588 if (obj3) {
40589 {
40590 arg4 = static_cast<int >(SWIG_As_int(obj3));
40591 if (SWIG_arg_fail(4)) SWIG_fail;
40592 }
40593 }
40594 if (obj4) {
40595 {
40596 arg5 = static_cast<int >(SWIG_As_int(obj4));
40597 if (SWIG_arg_fail(5)) SWIG_fail;
40598 }
40599 }
40600 if (obj5) {
40601 arg6 = obj5;
40602 }
40603 {
40604 PyThreadState* __tstate = wxPyBeginAllowThreads();
40605 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
40606
40607 wxPyEndAllowThreads(__tstate);
40608 if (PyErr_Occurred()) SWIG_fail;
40609 }
40610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40611 return resultobj;
40612 fail:
40613 return NULL;
40614 }
40615
40616
40617 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
40618 PyObject *resultobj = NULL;
40619 wxSizer *arg1 = (wxSizer *) 0 ;
40620 PyObject *arg2 = (PyObject *) 0 ;
40621 bool result;
40622 PyObject * obj0 = 0 ;
40623 PyObject * obj1 = 0 ;
40624 char *kwnames[] = {
40625 (char *) "self",(char *) "item", NULL
40626 };
40627
40628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
40629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40630 if (SWIG_arg_fail(1)) SWIG_fail;
40631 arg2 = obj1;
40632 {
40633 PyThreadState* __tstate = wxPyBeginAllowThreads();
40634 result = (bool)wxSizer_Remove(arg1,arg2);
40635
40636 wxPyEndAllowThreads(__tstate);
40637 if (PyErr_Occurred()) SWIG_fail;
40638 }
40639 {
40640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40641 }
40642 return resultobj;
40643 fail:
40644 return NULL;
40645 }
40646
40647
40648 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
40649 PyObject *resultobj = NULL;
40650 wxSizer *arg1 = (wxSizer *) 0 ;
40651 PyObject *arg2 = (PyObject *) 0 ;
40652 bool result;
40653 PyObject * obj0 = 0 ;
40654 PyObject * obj1 = 0 ;
40655 char *kwnames[] = {
40656 (char *) "self",(char *) "item", NULL
40657 };
40658
40659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
40660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40661 if (SWIG_arg_fail(1)) SWIG_fail;
40662 arg2 = obj1;
40663 {
40664 PyThreadState* __tstate = wxPyBeginAllowThreads();
40665 result = (bool)wxSizer_Detach(arg1,arg2);
40666
40667 wxPyEndAllowThreads(__tstate);
40668 if (PyErr_Occurred()) SWIG_fail;
40669 }
40670 {
40671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40672 }
40673 return resultobj;
40674 fail:
40675 return NULL;
40676 }
40677
40678
40679 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
40680 PyObject *resultobj = NULL;
40681 wxSizer *arg1 = (wxSizer *) 0 ;
40682 PyObject *arg2 = (PyObject *) 0 ;
40683 wxSizerItem *result;
40684 PyObject * obj0 = 0 ;
40685 PyObject * obj1 = 0 ;
40686 char *kwnames[] = {
40687 (char *) "self",(char *) "item", NULL
40688 };
40689
40690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
40691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40692 if (SWIG_arg_fail(1)) SWIG_fail;
40693 arg2 = obj1;
40694 {
40695 PyThreadState* __tstate = wxPyBeginAllowThreads();
40696 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
40697
40698 wxPyEndAllowThreads(__tstate);
40699 if (PyErr_Occurred()) SWIG_fail;
40700 }
40701 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40702 return resultobj;
40703 fail:
40704 return NULL;
40705 }
40706
40707
40708 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40709 PyObject *resultobj = NULL;
40710 wxSizer *arg1 = (wxSizer *) 0 ;
40711 PyObject *arg2 = (PyObject *) 0 ;
40712 wxSize *arg3 = 0 ;
40713 wxSize temp3 ;
40714 PyObject * obj0 = 0 ;
40715 PyObject * obj1 = 0 ;
40716 PyObject * obj2 = 0 ;
40717 char *kwnames[] = {
40718 (char *) "self",(char *) "item",(char *) "size", NULL
40719 };
40720
40721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
40722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40723 if (SWIG_arg_fail(1)) SWIG_fail;
40724 arg2 = obj1;
40725 {
40726 arg3 = &temp3;
40727 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
40728 }
40729 {
40730 PyThreadState* __tstate = wxPyBeginAllowThreads();
40731 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
40732
40733 wxPyEndAllowThreads(__tstate);
40734 if (PyErr_Occurred()) SWIG_fail;
40735 }
40736 Py_INCREF(Py_None); resultobj = Py_None;
40737 return resultobj;
40738 fail:
40739 return NULL;
40740 }
40741
40742
40743 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
40744 PyObject *resultobj = NULL;
40745 wxSizer *arg1 = (wxSizer *) 0 ;
40746 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40747 wxSizerItem *result;
40748 PyObject * obj0 = 0 ;
40749 PyObject * obj1 = 0 ;
40750 char *kwnames[] = {
40751 (char *) "self",(char *) "item", NULL
40752 };
40753
40754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
40755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40756 if (SWIG_arg_fail(1)) SWIG_fail;
40757 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40758 if (SWIG_arg_fail(2)) SWIG_fail;
40759 {
40760 PyThreadState* __tstate = wxPyBeginAllowThreads();
40761 result = (wxSizerItem *)(arg1)->Add(arg2);
40762
40763 wxPyEndAllowThreads(__tstate);
40764 if (PyErr_Occurred()) SWIG_fail;
40765 }
40766 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40767 return resultobj;
40768 fail:
40769 return NULL;
40770 }
40771
40772
40773 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
40774 PyObject *resultobj = NULL;
40775 wxSizer *arg1 = (wxSizer *) 0 ;
40776 size_t arg2 ;
40777 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
40778 wxSizerItem *result;
40779 PyObject * obj0 = 0 ;
40780 PyObject * obj1 = 0 ;
40781 PyObject * obj2 = 0 ;
40782 char *kwnames[] = {
40783 (char *) "self",(char *) "index",(char *) "item", NULL
40784 };
40785
40786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
40787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40788 if (SWIG_arg_fail(1)) SWIG_fail;
40789 {
40790 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
40791 if (SWIG_arg_fail(2)) SWIG_fail;
40792 }
40793 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40794 if (SWIG_arg_fail(3)) SWIG_fail;
40795 {
40796 PyThreadState* __tstate = wxPyBeginAllowThreads();
40797 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
40798
40799 wxPyEndAllowThreads(__tstate);
40800 if (PyErr_Occurred()) SWIG_fail;
40801 }
40802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40803 return resultobj;
40804 fail:
40805 return NULL;
40806 }
40807
40808
40809 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
40810 PyObject *resultobj = NULL;
40811 wxSizer *arg1 = (wxSizer *) 0 ;
40812 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40813 wxSizerItem *result;
40814 PyObject * obj0 = 0 ;
40815 PyObject * obj1 = 0 ;
40816 char *kwnames[] = {
40817 (char *) "self",(char *) "item", NULL
40818 };
40819
40820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
40821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40822 if (SWIG_arg_fail(1)) SWIG_fail;
40823 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40824 if (SWIG_arg_fail(2)) SWIG_fail;
40825 {
40826 PyThreadState* __tstate = wxPyBeginAllowThreads();
40827 result = (wxSizerItem *)(arg1)->Prepend(arg2);
40828
40829 wxPyEndAllowThreads(__tstate);
40830 if (PyErr_Occurred()) SWIG_fail;
40831 }
40832 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40833 return resultobj;
40834 fail:
40835 return NULL;
40836 }
40837
40838
40839 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
40840 PyObject *resultobj = NULL;
40841 wxSizer *arg1 = (wxSizer *) 0 ;
40842 int arg2 ;
40843 int arg3 ;
40844 int arg4 ;
40845 int arg5 ;
40846 PyObject * obj0 = 0 ;
40847 PyObject * obj1 = 0 ;
40848 PyObject * obj2 = 0 ;
40849 PyObject * obj3 = 0 ;
40850 PyObject * obj4 = 0 ;
40851 char *kwnames[] = {
40852 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40853 };
40854
40855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40857 if (SWIG_arg_fail(1)) SWIG_fail;
40858 {
40859 arg2 = static_cast<int >(SWIG_As_int(obj1));
40860 if (SWIG_arg_fail(2)) SWIG_fail;
40861 }
40862 {
40863 arg3 = static_cast<int >(SWIG_As_int(obj2));
40864 if (SWIG_arg_fail(3)) SWIG_fail;
40865 }
40866 {
40867 arg4 = static_cast<int >(SWIG_As_int(obj3));
40868 if (SWIG_arg_fail(4)) SWIG_fail;
40869 }
40870 {
40871 arg5 = static_cast<int >(SWIG_As_int(obj4));
40872 if (SWIG_arg_fail(5)) SWIG_fail;
40873 }
40874 {
40875 PyThreadState* __tstate = wxPyBeginAllowThreads();
40876 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40877
40878 wxPyEndAllowThreads(__tstate);
40879 if (PyErr_Occurred()) SWIG_fail;
40880 }
40881 Py_INCREF(Py_None); resultobj = Py_None;
40882 return resultobj;
40883 fail:
40884 return NULL;
40885 }
40886
40887
40888 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40889 PyObject *resultobj = NULL;
40890 wxSizer *arg1 = (wxSizer *) 0 ;
40891 wxSize *arg2 = 0 ;
40892 wxSize temp2 ;
40893 PyObject * obj0 = 0 ;
40894 PyObject * obj1 = 0 ;
40895 char *kwnames[] = {
40896 (char *) "self",(char *) "size", NULL
40897 };
40898
40899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40901 if (SWIG_arg_fail(1)) SWIG_fail;
40902 {
40903 arg2 = &temp2;
40904 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40905 }
40906 {
40907 PyThreadState* __tstate = wxPyBeginAllowThreads();
40908 (arg1)->SetMinSize((wxSize const &)*arg2);
40909
40910 wxPyEndAllowThreads(__tstate);
40911 if (PyErr_Occurred()) SWIG_fail;
40912 }
40913 Py_INCREF(Py_None); resultobj = Py_None;
40914 return resultobj;
40915 fail:
40916 return NULL;
40917 }
40918
40919
40920 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40921 PyObject *resultobj = NULL;
40922 wxSizer *arg1 = (wxSizer *) 0 ;
40923 wxSize result;
40924 PyObject * obj0 = 0 ;
40925 char *kwnames[] = {
40926 (char *) "self", NULL
40927 };
40928
40929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40931 if (SWIG_arg_fail(1)) SWIG_fail;
40932 {
40933 PyThreadState* __tstate = wxPyBeginAllowThreads();
40934 result = (arg1)->GetSize();
40935
40936 wxPyEndAllowThreads(__tstate);
40937 if (PyErr_Occurred()) SWIG_fail;
40938 }
40939 {
40940 wxSize * resultptr;
40941 resultptr = new wxSize(static_cast<wxSize & >(result));
40942 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40943 }
40944 return resultobj;
40945 fail:
40946 return NULL;
40947 }
40948
40949
40950 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40951 PyObject *resultobj = NULL;
40952 wxSizer *arg1 = (wxSizer *) 0 ;
40953 wxPoint result;
40954 PyObject * obj0 = 0 ;
40955 char *kwnames[] = {
40956 (char *) "self", NULL
40957 };
40958
40959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40961 if (SWIG_arg_fail(1)) SWIG_fail;
40962 {
40963 PyThreadState* __tstate = wxPyBeginAllowThreads();
40964 result = (arg1)->GetPosition();
40965
40966 wxPyEndAllowThreads(__tstate);
40967 if (PyErr_Occurred()) SWIG_fail;
40968 }
40969 {
40970 wxPoint * resultptr;
40971 resultptr = new wxPoint(static_cast<wxPoint & >(result));
40972 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40973 }
40974 return resultobj;
40975 fail:
40976 return NULL;
40977 }
40978
40979
40980 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40981 PyObject *resultobj = NULL;
40982 wxSizer *arg1 = (wxSizer *) 0 ;
40983 wxSize result;
40984 PyObject * obj0 = 0 ;
40985 char *kwnames[] = {
40986 (char *) "self", NULL
40987 };
40988
40989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40991 if (SWIG_arg_fail(1)) SWIG_fail;
40992 {
40993 PyThreadState* __tstate = wxPyBeginAllowThreads();
40994 result = (arg1)->GetMinSize();
40995
40996 wxPyEndAllowThreads(__tstate);
40997 if (PyErr_Occurred()) SWIG_fail;
40998 }
40999 {
41000 wxSize * resultptr;
41001 resultptr = new wxSize(static_cast<wxSize & >(result));
41002 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41003 }
41004 return resultobj;
41005 fail:
41006 return NULL;
41007 }
41008
41009
41010 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
41011 PyObject *resultobj = NULL;
41012 wxSizer *arg1 = (wxSizer *) 0 ;
41013 PyObject * obj0 = 0 ;
41014 char *kwnames[] = {
41015 (char *) "self", NULL
41016 };
41017
41018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
41019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41020 if (SWIG_arg_fail(1)) SWIG_fail;
41021 {
41022 PyThreadState* __tstate = wxPyBeginAllowThreads();
41023 (arg1)->RecalcSizes();
41024
41025 wxPyEndAllowThreads(__tstate);
41026 if (PyErr_Occurred()) SWIG_fail;
41027 }
41028 Py_INCREF(Py_None); resultobj = Py_None;
41029 return resultobj;
41030 fail:
41031 return NULL;
41032 }
41033
41034
41035 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
41036 PyObject *resultobj = NULL;
41037 wxSizer *arg1 = (wxSizer *) 0 ;
41038 wxSize result;
41039 PyObject * obj0 = 0 ;
41040 char *kwnames[] = {
41041 (char *) "self", NULL
41042 };
41043
41044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
41045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41046 if (SWIG_arg_fail(1)) SWIG_fail;
41047 {
41048 PyThreadState* __tstate = wxPyBeginAllowThreads();
41049 result = (arg1)->CalcMin();
41050
41051 wxPyEndAllowThreads(__tstate);
41052 if (PyErr_Occurred()) SWIG_fail;
41053 }
41054 {
41055 wxSize * resultptr;
41056 resultptr = new wxSize(static_cast<wxSize & >(result));
41057 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41058 }
41059 return resultobj;
41060 fail:
41061 return NULL;
41062 }
41063
41064
41065 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
41066 PyObject *resultobj = NULL;
41067 wxSizer *arg1 = (wxSizer *) 0 ;
41068 PyObject * obj0 = 0 ;
41069 char *kwnames[] = {
41070 (char *) "self", NULL
41071 };
41072
41073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
41074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41075 if (SWIG_arg_fail(1)) SWIG_fail;
41076 {
41077 PyThreadState* __tstate = wxPyBeginAllowThreads();
41078 (arg1)->Layout();
41079
41080 wxPyEndAllowThreads(__tstate);
41081 if (PyErr_Occurred()) SWIG_fail;
41082 }
41083 Py_INCREF(Py_None); resultobj = Py_None;
41084 return resultobj;
41085 fail:
41086 return NULL;
41087 }
41088
41089
41090 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
41091 PyObject *resultobj = NULL;
41092 wxSizer *arg1 = (wxSizer *) 0 ;
41093 wxWindow *arg2 = (wxWindow *) 0 ;
41094 wxSize result;
41095 PyObject * obj0 = 0 ;
41096 PyObject * obj1 = 0 ;
41097 char *kwnames[] = {
41098 (char *) "self",(char *) "window", NULL
41099 };
41100
41101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
41102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41103 if (SWIG_arg_fail(1)) SWIG_fail;
41104 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41105 if (SWIG_arg_fail(2)) SWIG_fail;
41106 {
41107 PyThreadState* __tstate = wxPyBeginAllowThreads();
41108 result = (arg1)->Fit(arg2);
41109
41110 wxPyEndAllowThreads(__tstate);
41111 if (PyErr_Occurred()) SWIG_fail;
41112 }
41113 {
41114 wxSize * resultptr;
41115 resultptr = new wxSize(static_cast<wxSize & >(result));
41116 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41117 }
41118 return resultobj;
41119 fail:
41120 return NULL;
41121 }
41122
41123
41124 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
41125 PyObject *resultobj = NULL;
41126 wxSizer *arg1 = (wxSizer *) 0 ;
41127 wxWindow *arg2 = (wxWindow *) 0 ;
41128 PyObject * obj0 = 0 ;
41129 PyObject * obj1 = 0 ;
41130 char *kwnames[] = {
41131 (char *) "self",(char *) "window", NULL
41132 };
41133
41134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
41135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41136 if (SWIG_arg_fail(1)) SWIG_fail;
41137 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41138 if (SWIG_arg_fail(2)) SWIG_fail;
41139 {
41140 PyThreadState* __tstate = wxPyBeginAllowThreads();
41141 (arg1)->FitInside(arg2);
41142
41143 wxPyEndAllowThreads(__tstate);
41144 if (PyErr_Occurred()) SWIG_fail;
41145 }
41146 Py_INCREF(Py_None); resultobj = Py_None;
41147 return resultobj;
41148 fail:
41149 return NULL;
41150 }
41151
41152
41153 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
41154 PyObject *resultobj = NULL;
41155 wxSizer *arg1 = (wxSizer *) 0 ;
41156 wxWindow *arg2 = (wxWindow *) 0 ;
41157 PyObject * obj0 = 0 ;
41158 PyObject * obj1 = 0 ;
41159 char *kwnames[] = {
41160 (char *) "self",(char *) "window", NULL
41161 };
41162
41163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
41164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41165 if (SWIG_arg_fail(1)) SWIG_fail;
41166 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41167 if (SWIG_arg_fail(2)) SWIG_fail;
41168 {
41169 PyThreadState* __tstate = wxPyBeginAllowThreads();
41170 (arg1)->SetSizeHints(arg2);
41171
41172 wxPyEndAllowThreads(__tstate);
41173 if (PyErr_Occurred()) SWIG_fail;
41174 }
41175 Py_INCREF(Py_None); resultobj = Py_None;
41176 return resultobj;
41177 fail:
41178 return NULL;
41179 }
41180
41181
41182 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
41183 PyObject *resultobj = NULL;
41184 wxSizer *arg1 = (wxSizer *) 0 ;
41185 wxWindow *arg2 = (wxWindow *) 0 ;
41186 PyObject * obj0 = 0 ;
41187 PyObject * obj1 = 0 ;
41188 char *kwnames[] = {
41189 (char *) "self",(char *) "window", NULL
41190 };
41191
41192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
41193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41194 if (SWIG_arg_fail(1)) SWIG_fail;
41195 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41196 if (SWIG_arg_fail(2)) SWIG_fail;
41197 {
41198 PyThreadState* __tstate = wxPyBeginAllowThreads();
41199 (arg1)->SetVirtualSizeHints(arg2);
41200
41201 wxPyEndAllowThreads(__tstate);
41202 if (PyErr_Occurred()) SWIG_fail;
41203 }
41204 Py_INCREF(Py_None); resultobj = Py_None;
41205 return resultobj;
41206 fail:
41207 return NULL;
41208 }
41209
41210
41211 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
41212 PyObject *resultobj = NULL;
41213 wxSizer *arg1 = (wxSizer *) 0 ;
41214 bool arg2 = (bool) false ;
41215 PyObject * obj0 = 0 ;
41216 PyObject * obj1 = 0 ;
41217 char *kwnames[] = {
41218 (char *) "self",(char *) "deleteWindows", NULL
41219 };
41220
41221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
41222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41223 if (SWIG_arg_fail(1)) SWIG_fail;
41224 if (obj1) {
41225 {
41226 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
41227 if (SWIG_arg_fail(2)) SWIG_fail;
41228 }
41229 }
41230 {
41231 PyThreadState* __tstate = wxPyBeginAllowThreads();
41232 (arg1)->Clear(arg2);
41233
41234 wxPyEndAllowThreads(__tstate);
41235 if (PyErr_Occurred()) SWIG_fail;
41236 }
41237 Py_INCREF(Py_None); resultobj = Py_None;
41238 return resultobj;
41239 fail:
41240 return NULL;
41241 }
41242
41243
41244 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
41245 PyObject *resultobj = NULL;
41246 wxSizer *arg1 = (wxSizer *) 0 ;
41247 PyObject * obj0 = 0 ;
41248 char *kwnames[] = {
41249 (char *) "self", NULL
41250 };
41251
41252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
41253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41254 if (SWIG_arg_fail(1)) SWIG_fail;
41255 {
41256 PyThreadState* __tstate = wxPyBeginAllowThreads();
41257 (arg1)->DeleteWindows();
41258
41259 wxPyEndAllowThreads(__tstate);
41260 if (PyErr_Occurred()) SWIG_fail;
41261 }
41262 Py_INCREF(Py_None); resultobj = Py_None;
41263 return resultobj;
41264 fail:
41265 return NULL;
41266 }
41267
41268
41269 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
41270 PyObject *resultobj = NULL;
41271 wxSizer *arg1 = (wxSizer *) 0 ;
41272 PyObject *result;
41273 PyObject * obj0 = 0 ;
41274 char *kwnames[] = {
41275 (char *) "self", NULL
41276 };
41277
41278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
41279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41280 if (SWIG_arg_fail(1)) SWIG_fail;
41281 {
41282 PyThreadState* __tstate = wxPyBeginAllowThreads();
41283 result = (PyObject *)wxSizer_GetChildren(arg1);
41284
41285 wxPyEndAllowThreads(__tstate);
41286 if (PyErr_Occurred()) SWIG_fail;
41287 }
41288 resultobj = result;
41289 return resultobj;
41290 fail:
41291 return NULL;
41292 }
41293
41294
41295 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
41296 PyObject *resultobj = NULL;
41297 wxSizer *arg1 = (wxSizer *) 0 ;
41298 PyObject *arg2 = (PyObject *) 0 ;
41299 bool arg3 = (bool) true ;
41300 bool arg4 = (bool) false ;
41301 bool result;
41302 PyObject * obj0 = 0 ;
41303 PyObject * obj1 = 0 ;
41304 PyObject * obj2 = 0 ;
41305 PyObject * obj3 = 0 ;
41306 char *kwnames[] = {
41307 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
41308 };
41309
41310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41312 if (SWIG_arg_fail(1)) SWIG_fail;
41313 arg2 = obj1;
41314 if (obj2) {
41315 {
41316 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
41317 if (SWIG_arg_fail(3)) SWIG_fail;
41318 }
41319 }
41320 if (obj3) {
41321 {
41322 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
41323 if (SWIG_arg_fail(4)) SWIG_fail;
41324 }
41325 }
41326 {
41327 PyThreadState* __tstate = wxPyBeginAllowThreads();
41328 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
41329
41330 wxPyEndAllowThreads(__tstate);
41331 if (PyErr_Occurred()) SWIG_fail;
41332 }
41333 {
41334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41335 }
41336 return resultobj;
41337 fail:
41338 return NULL;
41339 }
41340
41341
41342 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
41343 PyObject *resultobj = NULL;
41344 wxSizer *arg1 = (wxSizer *) 0 ;
41345 PyObject *arg2 = (PyObject *) 0 ;
41346 bool result;
41347 PyObject * obj0 = 0 ;
41348 PyObject * obj1 = 0 ;
41349 char *kwnames[] = {
41350 (char *) "self",(char *) "item", NULL
41351 };
41352
41353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
41354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41355 if (SWIG_arg_fail(1)) SWIG_fail;
41356 arg2 = obj1;
41357 {
41358 PyThreadState* __tstate = wxPyBeginAllowThreads();
41359 result = (bool)wxSizer_IsShown(arg1,arg2);
41360
41361 wxPyEndAllowThreads(__tstate);
41362 if (PyErr_Occurred()) SWIG_fail;
41363 }
41364 {
41365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41366 }
41367 return resultobj;
41368 fail:
41369 return NULL;
41370 }
41371
41372
41373 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
41374 PyObject *resultobj = NULL;
41375 wxSizer *arg1 = (wxSizer *) 0 ;
41376 bool arg2 ;
41377 PyObject * obj0 = 0 ;
41378 PyObject * obj1 = 0 ;
41379 char *kwnames[] = {
41380 (char *) "self",(char *) "show", NULL
41381 };
41382
41383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
41384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41385 if (SWIG_arg_fail(1)) SWIG_fail;
41386 {
41387 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
41388 if (SWIG_arg_fail(2)) SWIG_fail;
41389 }
41390 {
41391 PyThreadState* __tstate = wxPyBeginAllowThreads();
41392 (arg1)->ShowItems(arg2);
41393
41394 wxPyEndAllowThreads(__tstate);
41395 if (PyErr_Occurred()) SWIG_fail;
41396 }
41397 Py_INCREF(Py_None); resultobj = Py_None;
41398 return resultobj;
41399 fail:
41400 return NULL;
41401 }
41402
41403
41404 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
41405 PyObject *obj;
41406 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41407 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
41408 Py_INCREF(obj);
41409 return Py_BuildValue((char *)"");
41410 }
41411 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
41412 PyObject *resultobj = NULL;
41413 wxPySizer *result;
41414 char *kwnames[] = {
41415 NULL
41416 };
41417
41418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
41419 {
41420 PyThreadState* __tstate = wxPyBeginAllowThreads();
41421 result = (wxPySizer *)new wxPySizer();
41422
41423 wxPyEndAllowThreads(__tstate);
41424 if (PyErr_Occurred()) SWIG_fail;
41425 }
41426 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
41427 return resultobj;
41428 fail:
41429 return NULL;
41430 }
41431
41432
41433 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
41434 PyObject *resultobj = NULL;
41435 wxPySizer *arg1 = (wxPySizer *) 0 ;
41436 PyObject *arg2 = (PyObject *) 0 ;
41437 PyObject *arg3 = (PyObject *) 0 ;
41438 PyObject * obj0 = 0 ;
41439 PyObject * obj1 = 0 ;
41440 PyObject * obj2 = 0 ;
41441 char *kwnames[] = {
41442 (char *) "self",(char *) "self",(char *) "_class", NULL
41443 };
41444
41445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
41446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
41447 if (SWIG_arg_fail(1)) SWIG_fail;
41448 arg2 = obj1;
41449 arg3 = obj2;
41450 {
41451 PyThreadState* __tstate = wxPyBeginAllowThreads();
41452 (arg1)->_setCallbackInfo(arg2,arg3);
41453
41454 wxPyEndAllowThreads(__tstate);
41455 if (PyErr_Occurred()) SWIG_fail;
41456 }
41457 Py_INCREF(Py_None); resultobj = Py_None;
41458 return resultobj;
41459 fail:
41460 return NULL;
41461 }
41462
41463
41464 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
41465 PyObject *obj;
41466 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41467 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
41468 Py_INCREF(obj);
41469 return Py_BuildValue((char *)"");
41470 }
41471 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41472 PyObject *resultobj = NULL;
41473 int arg1 = (int) wxHORIZONTAL ;
41474 wxBoxSizer *result;
41475 PyObject * obj0 = 0 ;
41476 char *kwnames[] = {
41477 (char *) "orient", NULL
41478 };
41479
41480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
41481 if (obj0) {
41482 {
41483 arg1 = static_cast<int >(SWIG_As_int(obj0));
41484 if (SWIG_arg_fail(1)) SWIG_fail;
41485 }
41486 }
41487 {
41488 PyThreadState* __tstate = wxPyBeginAllowThreads();
41489 result = (wxBoxSizer *)new wxBoxSizer(arg1);
41490
41491 wxPyEndAllowThreads(__tstate);
41492 if (PyErr_Occurred()) SWIG_fail;
41493 }
41494 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
41495 return resultobj;
41496 fail:
41497 return NULL;
41498 }
41499
41500
41501 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41502 PyObject *resultobj = NULL;
41503 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41504 int result;
41505 PyObject * obj0 = 0 ;
41506 char *kwnames[] = {
41507 (char *) "self", NULL
41508 };
41509
41510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
41511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41512 if (SWIG_arg_fail(1)) SWIG_fail;
41513 {
41514 PyThreadState* __tstate = wxPyBeginAllowThreads();
41515 result = (int)(arg1)->GetOrientation();
41516
41517 wxPyEndAllowThreads(__tstate);
41518 if (PyErr_Occurred()) SWIG_fail;
41519 }
41520 {
41521 resultobj = SWIG_From_int(static_cast<int >(result));
41522 }
41523 return resultobj;
41524 fail:
41525 return NULL;
41526 }
41527
41528
41529 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41530 PyObject *resultobj = NULL;
41531 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41532 int arg2 ;
41533 PyObject * obj0 = 0 ;
41534 PyObject * obj1 = 0 ;
41535 char *kwnames[] = {
41536 (char *) "self",(char *) "orient", NULL
41537 };
41538
41539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
41540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41541 if (SWIG_arg_fail(1)) SWIG_fail;
41542 {
41543 arg2 = static_cast<int >(SWIG_As_int(obj1));
41544 if (SWIG_arg_fail(2)) SWIG_fail;
41545 }
41546 {
41547 PyThreadState* __tstate = wxPyBeginAllowThreads();
41548 (arg1)->SetOrientation(arg2);
41549
41550 wxPyEndAllowThreads(__tstate);
41551 if (PyErr_Occurred()) SWIG_fail;
41552 }
41553 Py_INCREF(Py_None); resultobj = Py_None;
41554 return resultobj;
41555 fail:
41556 return NULL;
41557 }
41558
41559
41560 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
41561 PyObject *obj;
41562 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41563 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
41564 Py_INCREF(obj);
41565 return Py_BuildValue((char *)"");
41566 }
41567 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41568 PyObject *resultobj = NULL;
41569 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
41570 int arg2 = (int) wxHORIZONTAL ;
41571 wxStaticBoxSizer *result;
41572 PyObject * obj0 = 0 ;
41573 PyObject * obj1 = 0 ;
41574 char *kwnames[] = {
41575 (char *) "box",(char *) "orient", NULL
41576 };
41577
41578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
41579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
41580 if (SWIG_arg_fail(1)) SWIG_fail;
41581 if (obj1) {
41582 {
41583 arg2 = static_cast<int >(SWIG_As_int(obj1));
41584 if (SWIG_arg_fail(2)) SWIG_fail;
41585 }
41586 }
41587 {
41588 PyThreadState* __tstate = wxPyBeginAllowThreads();
41589 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
41590
41591 wxPyEndAllowThreads(__tstate);
41592 if (PyErr_Occurred()) SWIG_fail;
41593 }
41594 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
41595 return resultobj;
41596 fail:
41597 return NULL;
41598 }
41599
41600
41601 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
41602 PyObject *resultobj = NULL;
41603 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
41604 wxStaticBox *result;
41605 PyObject * obj0 = 0 ;
41606 char *kwnames[] = {
41607 (char *) "self", NULL
41608 };
41609
41610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
41611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41612 if (SWIG_arg_fail(1)) SWIG_fail;
41613 {
41614 PyThreadState* __tstate = wxPyBeginAllowThreads();
41615 result = (wxStaticBox *)(arg1)->GetStaticBox();
41616
41617 wxPyEndAllowThreads(__tstate);
41618 if (PyErr_Occurred()) SWIG_fail;
41619 }
41620 {
41621 resultobj = wxPyMake_wxObject(result, 0);
41622 }
41623 return resultobj;
41624 fail:
41625 return NULL;
41626 }
41627
41628
41629 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
41630 PyObject *obj;
41631 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41632 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
41633 Py_INCREF(obj);
41634 return Py_BuildValue((char *)"");
41635 }
41636 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41637 PyObject *resultobj = NULL;
41638 int arg1 = (int) 1 ;
41639 int arg2 = (int) 0 ;
41640 int arg3 = (int) 0 ;
41641 int arg4 = (int) 0 ;
41642 wxGridSizer *result;
41643 PyObject * obj0 = 0 ;
41644 PyObject * obj1 = 0 ;
41645 PyObject * obj2 = 0 ;
41646 PyObject * obj3 = 0 ;
41647 char *kwnames[] = {
41648 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41649 };
41650
41651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41652 if (obj0) {
41653 {
41654 arg1 = static_cast<int >(SWIG_As_int(obj0));
41655 if (SWIG_arg_fail(1)) SWIG_fail;
41656 }
41657 }
41658 if (obj1) {
41659 {
41660 arg2 = static_cast<int >(SWIG_As_int(obj1));
41661 if (SWIG_arg_fail(2)) SWIG_fail;
41662 }
41663 }
41664 if (obj2) {
41665 {
41666 arg3 = static_cast<int >(SWIG_As_int(obj2));
41667 if (SWIG_arg_fail(3)) SWIG_fail;
41668 }
41669 }
41670 if (obj3) {
41671 {
41672 arg4 = static_cast<int >(SWIG_As_int(obj3));
41673 if (SWIG_arg_fail(4)) SWIG_fail;
41674 }
41675 }
41676 {
41677 PyThreadState* __tstate = wxPyBeginAllowThreads();
41678 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
41679
41680 wxPyEndAllowThreads(__tstate);
41681 if (PyErr_Occurred()) SWIG_fail;
41682 }
41683 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
41684 return resultobj;
41685 fail:
41686 return NULL;
41687 }
41688
41689
41690 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41691 PyObject *resultobj = NULL;
41692 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41693 int arg2 ;
41694 PyObject * obj0 = 0 ;
41695 PyObject * obj1 = 0 ;
41696 char *kwnames[] = {
41697 (char *) "self",(char *) "cols", NULL
41698 };
41699
41700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
41701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41702 if (SWIG_arg_fail(1)) SWIG_fail;
41703 {
41704 arg2 = static_cast<int >(SWIG_As_int(obj1));
41705 if (SWIG_arg_fail(2)) SWIG_fail;
41706 }
41707 {
41708 PyThreadState* __tstate = wxPyBeginAllowThreads();
41709 (arg1)->SetCols(arg2);
41710
41711 wxPyEndAllowThreads(__tstate);
41712 if (PyErr_Occurred()) SWIG_fail;
41713 }
41714 Py_INCREF(Py_None); resultobj = Py_None;
41715 return resultobj;
41716 fail:
41717 return NULL;
41718 }
41719
41720
41721 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41722 PyObject *resultobj = NULL;
41723 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41724 int arg2 ;
41725 PyObject * obj0 = 0 ;
41726 PyObject * obj1 = 0 ;
41727 char *kwnames[] = {
41728 (char *) "self",(char *) "rows", NULL
41729 };
41730
41731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
41732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41733 if (SWIG_arg_fail(1)) SWIG_fail;
41734 {
41735 arg2 = static_cast<int >(SWIG_As_int(obj1));
41736 if (SWIG_arg_fail(2)) SWIG_fail;
41737 }
41738 {
41739 PyThreadState* __tstate = wxPyBeginAllowThreads();
41740 (arg1)->SetRows(arg2);
41741
41742 wxPyEndAllowThreads(__tstate);
41743 if (PyErr_Occurred()) SWIG_fail;
41744 }
41745 Py_INCREF(Py_None); resultobj = Py_None;
41746 return resultobj;
41747 fail:
41748 return NULL;
41749 }
41750
41751
41752 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41753 PyObject *resultobj = NULL;
41754 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41755 int arg2 ;
41756 PyObject * obj0 = 0 ;
41757 PyObject * obj1 = 0 ;
41758 char *kwnames[] = {
41759 (char *) "self",(char *) "gap", NULL
41760 };
41761
41762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
41763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41764 if (SWIG_arg_fail(1)) SWIG_fail;
41765 {
41766 arg2 = static_cast<int >(SWIG_As_int(obj1));
41767 if (SWIG_arg_fail(2)) SWIG_fail;
41768 }
41769 {
41770 PyThreadState* __tstate = wxPyBeginAllowThreads();
41771 (arg1)->SetVGap(arg2);
41772
41773 wxPyEndAllowThreads(__tstate);
41774 if (PyErr_Occurred()) SWIG_fail;
41775 }
41776 Py_INCREF(Py_None); resultobj = Py_None;
41777 return resultobj;
41778 fail:
41779 return NULL;
41780 }
41781
41782
41783 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41784 PyObject *resultobj = NULL;
41785 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41786 int arg2 ;
41787 PyObject * obj0 = 0 ;
41788 PyObject * obj1 = 0 ;
41789 char *kwnames[] = {
41790 (char *) "self",(char *) "gap", NULL
41791 };
41792
41793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
41794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41795 if (SWIG_arg_fail(1)) SWIG_fail;
41796 {
41797 arg2 = static_cast<int >(SWIG_As_int(obj1));
41798 if (SWIG_arg_fail(2)) SWIG_fail;
41799 }
41800 {
41801 PyThreadState* __tstate = wxPyBeginAllowThreads();
41802 (arg1)->SetHGap(arg2);
41803
41804 wxPyEndAllowThreads(__tstate);
41805 if (PyErr_Occurred()) SWIG_fail;
41806 }
41807 Py_INCREF(Py_None); resultobj = Py_None;
41808 return resultobj;
41809 fail:
41810 return NULL;
41811 }
41812
41813
41814 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41815 PyObject *resultobj = NULL;
41816 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41817 int result;
41818 PyObject * obj0 = 0 ;
41819 char *kwnames[] = {
41820 (char *) "self", NULL
41821 };
41822
41823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
41824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41825 if (SWIG_arg_fail(1)) SWIG_fail;
41826 {
41827 PyThreadState* __tstate = wxPyBeginAllowThreads();
41828 result = (int)(arg1)->GetCols();
41829
41830 wxPyEndAllowThreads(__tstate);
41831 if (PyErr_Occurred()) SWIG_fail;
41832 }
41833 {
41834 resultobj = SWIG_From_int(static_cast<int >(result));
41835 }
41836 return resultobj;
41837 fail:
41838 return NULL;
41839 }
41840
41841
41842 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41843 PyObject *resultobj = NULL;
41844 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41845 int result;
41846 PyObject * obj0 = 0 ;
41847 char *kwnames[] = {
41848 (char *) "self", NULL
41849 };
41850
41851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41853 if (SWIG_arg_fail(1)) SWIG_fail;
41854 {
41855 PyThreadState* __tstate = wxPyBeginAllowThreads();
41856 result = (int)(arg1)->GetRows();
41857
41858 wxPyEndAllowThreads(__tstate);
41859 if (PyErr_Occurred()) SWIG_fail;
41860 }
41861 {
41862 resultobj = SWIG_From_int(static_cast<int >(result));
41863 }
41864 return resultobj;
41865 fail:
41866 return NULL;
41867 }
41868
41869
41870 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41871 PyObject *resultobj = NULL;
41872 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41873 int result;
41874 PyObject * obj0 = 0 ;
41875 char *kwnames[] = {
41876 (char *) "self", NULL
41877 };
41878
41879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41881 if (SWIG_arg_fail(1)) SWIG_fail;
41882 {
41883 PyThreadState* __tstate = wxPyBeginAllowThreads();
41884 result = (int)(arg1)->GetVGap();
41885
41886 wxPyEndAllowThreads(__tstate);
41887 if (PyErr_Occurred()) SWIG_fail;
41888 }
41889 {
41890 resultobj = SWIG_From_int(static_cast<int >(result));
41891 }
41892 return resultobj;
41893 fail:
41894 return NULL;
41895 }
41896
41897
41898 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41899 PyObject *resultobj = NULL;
41900 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41901 int result;
41902 PyObject * obj0 = 0 ;
41903 char *kwnames[] = {
41904 (char *) "self", NULL
41905 };
41906
41907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41909 if (SWIG_arg_fail(1)) SWIG_fail;
41910 {
41911 PyThreadState* __tstate = wxPyBeginAllowThreads();
41912 result = (int)(arg1)->GetHGap();
41913
41914 wxPyEndAllowThreads(__tstate);
41915 if (PyErr_Occurred()) SWIG_fail;
41916 }
41917 {
41918 resultobj = SWIG_From_int(static_cast<int >(result));
41919 }
41920 return resultobj;
41921 fail:
41922 return NULL;
41923 }
41924
41925
41926 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41927 PyObject *obj;
41928 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41929 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41930 Py_INCREF(obj);
41931 return Py_BuildValue((char *)"");
41932 }
41933 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41934 PyObject *resultobj = NULL;
41935 int arg1 = (int) 1 ;
41936 int arg2 = (int) 0 ;
41937 int arg3 = (int) 0 ;
41938 int arg4 = (int) 0 ;
41939 wxFlexGridSizer *result;
41940 PyObject * obj0 = 0 ;
41941 PyObject * obj1 = 0 ;
41942 PyObject * obj2 = 0 ;
41943 PyObject * obj3 = 0 ;
41944 char *kwnames[] = {
41945 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41946 };
41947
41948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41949 if (obj0) {
41950 {
41951 arg1 = static_cast<int >(SWIG_As_int(obj0));
41952 if (SWIG_arg_fail(1)) SWIG_fail;
41953 }
41954 }
41955 if (obj1) {
41956 {
41957 arg2 = static_cast<int >(SWIG_As_int(obj1));
41958 if (SWIG_arg_fail(2)) SWIG_fail;
41959 }
41960 }
41961 if (obj2) {
41962 {
41963 arg3 = static_cast<int >(SWIG_As_int(obj2));
41964 if (SWIG_arg_fail(3)) SWIG_fail;
41965 }
41966 }
41967 if (obj3) {
41968 {
41969 arg4 = static_cast<int >(SWIG_As_int(obj3));
41970 if (SWIG_arg_fail(4)) SWIG_fail;
41971 }
41972 }
41973 {
41974 PyThreadState* __tstate = wxPyBeginAllowThreads();
41975 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41976
41977 wxPyEndAllowThreads(__tstate);
41978 if (PyErr_Occurred()) SWIG_fail;
41979 }
41980 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41981 return resultobj;
41982 fail:
41983 return NULL;
41984 }
41985
41986
41987 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41988 PyObject *resultobj = NULL;
41989 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41990 size_t arg2 ;
41991 int arg3 = (int) 0 ;
41992 PyObject * obj0 = 0 ;
41993 PyObject * obj1 = 0 ;
41994 PyObject * obj2 = 0 ;
41995 char *kwnames[] = {
41996 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41997 };
41998
41999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
42000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42001 if (SWIG_arg_fail(1)) SWIG_fail;
42002 {
42003 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42004 if (SWIG_arg_fail(2)) SWIG_fail;
42005 }
42006 if (obj2) {
42007 {
42008 arg3 = static_cast<int >(SWIG_As_int(obj2));
42009 if (SWIG_arg_fail(3)) SWIG_fail;
42010 }
42011 }
42012 {
42013 PyThreadState* __tstate = wxPyBeginAllowThreads();
42014 (arg1)->AddGrowableRow(arg2,arg3);
42015
42016 wxPyEndAllowThreads(__tstate);
42017 if (PyErr_Occurred()) SWIG_fail;
42018 }
42019 Py_INCREF(Py_None); resultobj = Py_None;
42020 return resultobj;
42021 fail:
42022 return NULL;
42023 }
42024
42025
42026 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
42027 PyObject *resultobj = NULL;
42028 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42029 size_t arg2 ;
42030 PyObject * obj0 = 0 ;
42031 PyObject * obj1 = 0 ;
42032 char *kwnames[] = {
42033 (char *) "self",(char *) "idx", NULL
42034 };
42035
42036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
42037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42038 if (SWIG_arg_fail(1)) SWIG_fail;
42039 {
42040 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42041 if (SWIG_arg_fail(2)) SWIG_fail;
42042 }
42043 {
42044 PyThreadState* __tstate = wxPyBeginAllowThreads();
42045 (arg1)->RemoveGrowableRow(arg2);
42046
42047 wxPyEndAllowThreads(__tstate);
42048 if (PyErr_Occurred()) SWIG_fail;
42049 }
42050 Py_INCREF(Py_None); resultobj = Py_None;
42051 return resultobj;
42052 fail:
42053 return NULL;
42054 }
42055
42056
42057 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
42058 PyObject *resultobj = NULL;
42059 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42060 size_t arg2 ;
42061 int arg3 = (int) 0 ;
42062 PyObject * obj0 = 0 ;
42063 PyObject * obj1 = 0 ;
42064 PyObject * obj2 = 0 ;
42065 char *kwnames[] = {
42066 (char *) "self",(char *) "idx",(char *) "proportion", NULL
42067 };
42068
42069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
42070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42071 if (SWIG_arg_fail(1)) SWIG_fail;
42072 {
42073 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42074 if (SWIG_arg_fail(2)) SWIG_fail;
42075 }
42076 if (obj2) {
42077 {
42078 arg3 = static_cast<int >(SWIG_As_int(obj2));
42079 if (SWIG_arg_fail(3)) SWIG_fail;
42080 }
42081 }
42082 {
42083 PyThreadState* __tstate = wxPyBeginAllowThreads();
42084 (arg1)->AddGrowableCol(arg2,arg3);
42085
42086 wxPyEndAllowThreads(__tstate);
42087 if (PyErr_Occurred()) SWIG_fail;
42088 }
42089 Py_INCREF(Py_None); resultobj = Py_None;
42090 return resultobj;
42091 fail:
42092 return NULL;
42093 }
42094
42095
42096 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
42097 PyObject *resultobj = NULL;
42098 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42099 size_t arg2 ;
42100 PyObject * obj0 = 0 ;
42101 PyObject * obj1 = 0 ;
42102 char *kwnames[] = {
42103 (char *) "self",(char *) "idx", NULL
42104 };
42105
42106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
42107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42108 if (SWIG_arg_fail(1)) SWIG_fail;
42109 {
42110 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42111 if (SWIG_arg_fail(2)) SWIG_fail;
42112 }
42113 {
42114 PyThreadState* __tstate = wxPyBeginAllowThreads();
42115 (arg1)->RemoveGrowableCol(arg2);
42116
42117 wxPyEndAllowThreads(__tstate);
42118 if (PyErr_Occurred()) SWIG_fail;
42119 }
42120 Py_INCREF(Py_None); resultobj = Py_None;
42121 return resultobj;
42122 fail:
42123 return NULL;
42124 }
42125
42126
42127 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
42128 PyObject *resultobj = NULL;
42129 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42130 int arg2 ;
42131 PyObject * obj0 = 0 ;
42132 PyObject * obj1 = 0 ;
42133 char *kwnames[] = {
42134 (char *) "self",(char *) "direction", NULL
42135 };
42136
42137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
42138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42139 if (SWIG_arg_fail(1)) SWIG_fail;
42140 {
42141 arg2 = static_cast<int >(SWIG_As_int(obj1));
42142 if (SWIG_arg_fail(2)) SWIG_fail;
42143 }
42144 {
42145 PyThreadState* __tstate = wxPyBeginAllowThreads();
42146 (arg1)->SetFlexibleDirection(arg2);
42147
42148 wxPyEndAllowThreads(__tstate);
42149 if (PyErr_Occurred()) SWIG_fail;
42150 }
42151 Py_INCREF(Py_None); resultobj = Py_None;
42152 return resultobj;
42153 fail:
42154 return NULL;
42155 }
42156
42157
42158 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
42159 PyObject *resultobj = NULL;
42160 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42161 int result;
42162 PyObject * obj0 = 0 ;
42163 char *kwnames[] = {
42164 (char *) "self", NULL
42165 };
42166
42167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
42168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42169 if (SWIG_arg_fail(1)) SWIG_fail;
42170 {
42171 PyThreadState* __tstate = wxPyBeginAllowThreads();
42172 result = (int)(arg1)->GetFlexibleDirection();
42173
42174 wxPyEndAllowThreads(__tstate);
42175 if (PyErr_Occurred()) SWIG_fail;
42176 }
42177 {
42178 resultobj = SWIG_From_int(static_cast<int >(result));
42179 }
42180 return resultobj;
42181 fail:
42182 return NULL;
42183 }
42184
42185
42186 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
42187 PyObject *resultobj = NULL;
42188 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42189 wxFlexSizerGrowMode arg2 ;
42190 PyObject * obj0 = 0 ;
42191 PyObject * obj1 = 0 ;
42192 char *kwnames[] = {
42193 (char *) "self",(char *) "mode", NULL
42194 };
42195
42196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
42197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42198 if (SWIG_arg_fail(1)) SWIG_fail;
42199 {
42200 arg2 = static_cast<wxFlexSizerGrowMode >(SWIG_As_int(obj1));
42201 if (SWIG_arg_fail(2)) SWIG_fail;
42202 }
42203 {
42204 PyThreadState* __tstate = wxPyBeginAllowThreads();
42205 (arg1)->SetNonFlexibleGrowMode(arg2);
42206
42207 wxPyEndAllowThreads(__tstate);
42208 if (PyErr_Occurred()) SWIG_fail;
42209 }
42210 Py_INCREF(Py_None); resultobj = Py_None;
42211 return resultobj;
42212 fail:
42213 return NULL;
42214 }
42215
42216
42217 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
42218 PyObject *resultobj = NULL;
42219 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42220 wxFlexSizerGrowMode result;
42221 PyObject * obj0 = 0 ;
42222 char *kwnames[] = {
42223 (char *) "self", NULL
42224 };
42225
42226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
42227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42228 if (SWIG_arg_fail(1)) SWIG_fail;
42229 {
42230 PyThreadState* __tstate = wxPyBeginAllowThreads();
42231 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
42232
42233 wxPyEndAllowThreads(__tstate);
42234 if (PyErr_Occurred()) SWIG_fail;
42235 }
42236 resultobj = SWIG_From_int((result));
42237 return resultobj;
42238 fail:
42239 return NULL;
42240 }
42241
42242
42243 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
42244 PyObject *resultobj = NULL;
42245 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42246 wxArrayInt *result;
42247 PyObject * obj0 = 0 ;
42248 char *kwnames[] = {
42249 (char *) "self", NULL
42250 };
42251
42252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
42253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42254 if (SWIG_arg_fail(1)) SWIG_fail;
42255 {
42256 PyThreadState* __tstate = wxPyBeginAllowThreads();
42257 {
42258 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
42259 result = (wxArrayInt *) &_result_ref;
42260 }
42261
42262 wxPyEndAllowThreads(__tstate);
42263 if (PyErr_Occurred()) SWIG_fail;
42264 }
42265 {
42266 resultobj = PyList_New(0);
42267 size_t idx;
42268 for (idx = 0; idx < result->GetCount(); idx += 1) {
42269 PyObject* val = PyInt_FromLong( result->Item(idx) );
42270 PyList_Append(resultobj, val);
42271 Py_DECREF(val);
42272 }
42273 }
42274 return resultobj;
42275 fail:
42276 return NULL;
42277 }
42278
42279
42280 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
42281 PyObject *resultobj = NULL;
42282 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42283 wxArrayInt *result;
42284 PyObject * obj0 = 0 ;
42285 char *kwnames[] = {
42286 (char *) "self", NULL
42287 };
42288
42289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
42290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42291 if (SWIG_arg_fail(1)) SWIG_fail;
42292 {
42293 PyThreadState* __tstate = wxPyBeginAllowThreads();
42294 {
42295 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
42296 result = (wxArrayInt *) &_result_ref;
42297 }
42298
42299 wxPyEndAllowThreads(__tstate);
42300 if (PyErr_Occurred()) SWIG_fail;
42301 }
42302 {
42303 resultobj = PyList_New(0);
42304 size_t idx;
42305 for (idx = 0; idx < result->GetCount(); idx += 1) {
42306 PyObject* val = PyInt_FromLong( result->Item(idx) );
42307 PyList_Append(resultobj, val);
42308 Py_DECREF(val);
42309 }
42310 }
42311 return resultobj;
42312 fail:
42313 return NULL;
42314 }
42315
42316
42317 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
42318 PyObject *obj;
42319 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42320 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
42321 Py_INCREF(obj);
42322 return Py_BuildValue((char *)"");
42323 }
42324 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42325 PyObject *resultobj = NULL;
42326 wxStdDialogButtonSizer *result;
42327 char *kwnames[] = {
42328 NULL
42329 };
42330
42331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
42332 {
42333 PyThreadState* __tstate = wxPyBeginAllowThreads();
42334 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
42335
42336 wxPyEndAllowThreads(__tstate);
42337 if (PyErr_Occurred()) SWIG_fail;
42338 }
42339 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
42340 return resultobj;
42341 fail:
42342 return NULL;
42343 }
42344
42345
42346 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
42347 PyObject *resultobj = NULL;
42348 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42349 wxButton *arg2 = (wxButton *) 0 ;
42350 PyObject * obj0 = 0 ;
42351 PyObject * obj1 = 0 ;
42352 char *kwnames[] = {
42353 (char *) "self",(char *) "button", NULL
42354 };
42355
42356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
42357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42358 if (SWIG_arg_fail(1)) SWIG_fail;
42359 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42360 if (SWIG_arg_fail(2)) SWIG_fail;
42361 {
42362 PyThreadState* __tstate = wxPyBeginAllowThreads();
42363 (arg1)->AddButton(arg2);
42364
42365 wxPyEndAllowThreads(__tstate);
42366 if (PyErr_Occurred()) SWIG_fail;
42367 }
42368 Py_INCREF(Py_None); resultobj = Py_None;
42369 return resultobj;
42370 fail:
42371 return NULL;
42372 }
42373
42374
42375 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
42376 PyObject *resultobj = NULL;
42377 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42378 PyObject * obj0 = 0 ;
42379 char *kwnames[] = {
42380 (char *) "self", NULL
42381 };
42382
42383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
42384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42385 if (SWIG_arg_fail(1)) SWIG_fail;
42386 {
42387 PyThreadState* __tstate = wxPyBeginAllowThreads();
42388 (arg1)->Realize();
42389
42390 wxPyEndAllowThreads(__tstate);
42391 if (PyErr_Occurred()) SWIG_fail;
42392 }
42393 Py_INCREF(Py_None); resultobj = Py_None;
42394 return resultobj;
42395 fail:
42396 return NULL;
42397 }
42398
42399
42400 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42401 PyObject *resultobj = NULL;
42402 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42403 wxButton *arg2 = (wxButton *) 0 ;
42404 PyObject * obj0 = 0 ;
42405 PyObject * obj1 = 0 ;
42406 char *kwnames[] = {
42407 (char *) "self",(char *) "button", NULL
42408 };
42409
42410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
42411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42412 if (SWIG_arg_fail(1)) SWIG_fail;
42413 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42414 if (SWIG_arg_fail(2)) SWIG_fail;
42415 {
42416 PyThreadState* __tstate = wxPyBeginAllowThreads();
42417 (arg1)->SetAffirmativeButton(arg2);
42418
42419 wxPyEndAllowThreads(__tstate);
42420 if (PyErr_Occurred()) SWIG_fail;
42421 }
42422 Py_INCREF(Py_None); resultobj = Py_None;
42423 return resultobj;
42424 fail:
42425 return NULL;
42426 }
42427
42428
42429 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42430 PyObject *resultobj = NULL;
42431 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42432 wxButton *arg2 = (wxButton *) 0 ;
42433 PyObject * obj0 = 0 ;
42434 PyObject * obj1 = 0 ;
42435 char *kwnames[] = {
42436 (char *) "self",(char *) "button", NULL
42437 };
42438
42439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
42440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42441 if (SWIG_arg_fail(1)) SWIG_fail;
42442 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42443 if (SWIG_arg_fail(2)) SWIG_fail;
42444 {
42445 PyThreadState* __tstate = wxPyBeginAllowThreads();
42446 (arg1)->SetNegativeButton(arg2);
42447
42448 wxPyEndAllowThreads(__tstate);
42449 if (PyErr_Occurred()) SWIG_fail;
42450 }
42451 Py_INCREF(Py_None); resultobj = Py_None;
42452 return resultobj;
42453 fail:
42454 return NULL;
42455 }
42456
42457
42458 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42459 PyObject *resultobj = NULL;
42460 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42461 wxButton *arg2 = (wxButton *) 0 ;
42462 PyObject * obj0 = 0 ;
42463 PyObject * obj1 = 0 ;
42464 char *kwnames[] = {
42465 (char *) "self",(char *) "button", NULL
42466 };
42467
42468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
42469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42470 if (SWIG_arg_fail(1)) SWIG_fail;
42471 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42472 if (SWIG_arg_fail(2)) SWIG_fail;
42473 {
42474 PyThreadState* __tstate = wxPyBeginAllowThreads();
42475 (arg1)->SetCancelButton(arg2);
42476
42477 wxPyEndAllowThreads(__tstate);
42478 if (PyErr_Occurred()) SWIG_fail;
42479 }
42480 Py_INCREF(Py_None); resultobj = Py_None;
42481 return resultobj;
42482 fail:
42483 return NULL;
42484 }
42485
42486
42487 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42488 PyObject *resultobj = NULL;
42489 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42490 wxButton *result;
42491 PyObject * obj0 = 0 ;
42492 char *kwnames[] = {
42493 (char *) "self", NULL
42494 };
42495
42496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
42497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42498 if (SWIG_arg_fail(1)) SWIG_fail;
42499 {
42500 PyThreadState* __tstate = wxPyBeginAllowThreads();
42501 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
42502
42503 wxPyEndAllowThreads(__tstate);
42504 if (PyErr_Occurred()) SWIG_fail;
42505 }
42506 {
42507 resultobj = wxPyMake_wxObject(result, 0);
42508 }
42509 return resultobj;
42510 fail:
42511 return NULL;
42512 }
42513
42514
42515 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
42516 PyObject *resultobj = NULL;
42517 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42518 wxButton *result;
42519 PyObject * obj0 = 0 ;
42520 char *kwnames[] = {
42521 (char *) "self", NULL
42522 };
42523
42524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
42525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42526 if (SWIG_arg_fail(1)) SWIG_fail;
42527 {
42528 PyThreadState* __tstate = wxPyBeginAllowThreads();
42529 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
42530
42531 wxPyEndAllowThreads(__tstate);
42532 if (PyErr_Occurred()) SWIG_fail;
42533 }
42534 {
42535 resultobj = wxPyMake_wxObject(result, 0);
42536 }
42537 return resultobj;
42538 fail:
42539 return NULL;
42540 }
42541
42542
42543 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42544 PyObject *resultobj = NULL;
42545 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42546 wxButton *result;
42547 PyObject * obj0 = 0 ;
42548 char *kwnames[] = {
42549 (char *) "self", NULL
42550 };
42551
42552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
42553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42554 if (SWIG_arg_fail(1)) SWIG_fail;
42555 {
42556 PyThreadState* __tstate = wxPyBeginAllowThreads();
42557 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
42558
42559 wxPyEndAllowThreads(__tstate);
42560 if (PyErr_Occurred()) SWIG_fail;
42561 }
42562 {
42563 resultobj = wxPyMake_wxObject(result, 0);
42564 }
42565 return resultobj;
42566 fail:
42567 return NULL;
42568 }
42569
42570
42571 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42572 PyObject *resultobj = NULL;
42573 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42574 wxButton *result;
42575 PyObject * obj0 = 0 ;
42576 char *kwnames[] = {
42577 (char *) "self", NULL
42578 };
42579
42580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
42581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42582 if (SWIG_arg_fail(1)) SWIG_fail;
42583 {
42584 PyThreadState* __tstate = wxPyBeginAllowThreads();
42585 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
42586
42587 wxPyEndAllowThreads(__tstate);
42588 if (PyErr_Occurred()) SWIG_fail;
42589 }
42590 {
42591 resultobj = wxPyMake_wxObject(result, 0);
42592 }
42593 return resultobj;
42594 fail:
42595 return NULL;
42596 }
42597
42598
42599 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
42600 PyObject *resultobj = NULL;
42601 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42602 wxButton *result;
42603 PyObject * obj0 = 0 ;
42604 char *kwnames[] = {
42605 (char *) "self", NULL
42606 };
42607
42608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
42609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42610 if (SWIG_arg_fail(1)) SWIG_fail;
42611 {
42612 PyThreadState* __tstate = wxPyBeginAllowThreads();
42613 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
42614
42615 wxPyEndAllowThreads(__tstate);
42616 if (PyErr_Occurred()) SWIG_fail;
42617 }
42618 {
42619 resultobj = wxPyMake_wxObject(result, 0);
42620 }
42621 return resultobj;
42622 fail:
42623 return NULL;
42624 }
42625
42626
42627 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
42628 PyObject *obj;
42629 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42630 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
42631 Py_INCREF(obj);
42632 return Py_BuildValue((char *)"");
42633 }
42634 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42635 PyObject *resultobj = NULL;
42636 int arg1 = (int) 0 ;
42637 int arg2 = (int) 0 ;
42638 wxGBPosition *result;
42639 PyObject * obj0 = 0 ;
42640 PyObject * obj1 = 0 ;
42641 char *kwnames[] = {
42642 (char *) "row",(char *) "col", NULL
42643 };
42644
42645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
42646 if (obj0) {
42647 {
42648 arg1 = static_cast<int >(SWIG_As_int(obj0));
42649 if (SWIG_arg_fail(1)) SWIG_fail;
42650 }
42651 }
42652 if (obj1) {
42653 {
42654 arg2 = static_cast<int >(SWIG_As_int(obj1));
42655 if (SWIG_arg_fail(2)) SWIG_fail;
42656 }
42657 }
42658 {
42659 PyThreadState* __tstate = wxPyBeginAllowThreads();
42660 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
42661
42662 wxPyEndAllowThreads(__tstate);
42663 if (PyErr_Occurred()) SWIG_fail;
42664 }
42665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
42666 return resultobj;
42667 fail:
42668 return NULL;
42669 }
42670
42671
42672 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42673 PyObject *resultobj = NULL;
42674 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42675 int result;
42676 PyObject * obj0 = 0 ;
42677 char *kwnames[] = {
42678 (char *) "self", NULL
42679 };
42680
42681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
42682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42683 if (SWIG_arg_fail(1)) SWIG_fail;
42684 {
42685 PyThreadState* __tstate = wxPyBeginAllowThreads();
42686 result = (int)((wxGBPosition const *)arg1)->GetRow();
42687
42688 wxPyEndAllowThreads(__tstate);
42689 if (PyErr_Occurred()) SWIG_fail;
42690 }
42691 {
42692 resultobj = SWIG_From_int(static_cast<int >(result));
42693 }
42694 return resultobj;
42695 fail:
42696 return NULL;
42697 }
42698
42699
42700 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42701 PyObject *resultobj = NULL;
42702 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42703 int result;
42704 PyObject * obj0 = 0 ;
42705 char *kwnames[] = {
42706 (char *) "self", NULL
42707 };
42708
42709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
42710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42711 if (SWIG_arg_fail(1)) SWIG_fail;
42712 {
42713 PyThreadState* __tstate = wxPyBeginAllowThreads();
42714 result = (int)((wxGBPosition const *)arg1)->GetCol();
42715
42716 wxPyEndAllowThreads(__tstate);
42717 if (PyErr_Occurred()) SWIG_fail;
42718 }
42719 {
42720 resultobj = SWIG_From_int(static_cast<int >(result));
42721 }
42722 return resultobj;
42723 fail:
42724 return NULL;
42725 }
42726
42727
42728 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42729 PyObject *resultobj = NULL;
42730 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42731 int arg2 ;
42732 PyObject * obj0 = 0 ;
42733 PyObject * obj1 = 0 ;
42734 char *kwnames[] = {
42735 (char *) "self",(char *) "row", NULL
42736 };
42737
42738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
42739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42740 if (SWIG_arg_fail(1)) SWIG_fail;
42741 {
42742 arg2 = static_cast<int >(SWIG_As_int(obj1));
42743 if (SWIG_arg_fail(2)) SWIG_fail;
42744 }
42745 {
42746 PyThreadState* __tstate = wxPyBeginAllowThreads();
42747 (arg1)->SetRow(arg2);
42748
42749 wxPyEndAllowThreads(__tstate);
42750 if (PyErr_Occurred()) SWIG_fail;
42751 }
42752 Py_INCREF(Py_None); resultobj = Py_None;
42753 return resultobj;
42754 fail:
42755 return NULL;
42756 }
42757
42758
42759 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42760 PyObject *resultobj = NULL;
42761 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42762 int arg2 ;
42763 PyObject * obj0 = 0 ;
42764 PyObject * obj1 = 0 ;
42765 char *kwnames[] = {
42766 (char *) "self",(char *) "col", NULL
42767 };
42768
42769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
42770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42771 if (SWIG_arg_fail(1)) SWIG_fail;
42772 {
42773 arg2 = static_cast<int >(SWIG_As_int(obj1));
42774 if (SWIG_arg_fail(2)) SWIG_fail;
42775 }
42776 {
42777 PyThreadState* __tstate = wxPyBeginAllowThreads();
42778 (arg1)->SetCol(arg2);
42779
42780 wxPyEndAllowThreads(__tstate);
42781 if (PyErr_Occurred()) SWIG_fail;
42782 }
42783 Py_INCREF(Py_None); resultobj = Py_None;
42784 return resultobj;
42785 fail:
42786 return NULL;
42787 }
42788
42789
42790 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42791 PyObject *resultobj = NULL;
42792 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42793 wxGBPosition *arg2 = 0 ;
42794 bool result;
42795 wxGBPosition temp2 ;
42796 PyObject * obj0 = 0 ;
42797 PyObject * obj1 = 0 ;
42798 char *kwnames[] = {
42799 (char *) "self",(char *) "other", NULL
42800 };
42801
42802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
42803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42804 if (SWIG_arg_fail(1)) SWIG_fail;
42805 {
42806 arg2 = &temp2;
42807 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42808 }
42809 {
42810 PyThreadState* __tstate = wxPyBeginAllowThreads();
42811 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
42812
42813 wxPyEndAllowThreads(__tstate);
42814 if (PyErr_Occurred()) SWIG_fail;
42815 }
42816 {
42817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42818 }
42819 return resultobj;
42820 fail:
42821 return NULL;
42822 }
42823
42824
42825 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42826 PyObject *resultobj = NULL;
42827 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42828 wxGBPosition *arg2 = 0 ;
42829 bool result;
42830 wxGBPosition temp2 ;
42831 PyObject * obj0 = 0 ;
42832 PyObject * obj1 = 0 ;
42833 char *kwnames[] = {
42834 (char *) "self",(char *) "other", NULL
42835 };
42836
42837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
42838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42839 if (SWIG_arg_fail(1)) SWIG_fail;
42840 {
42841 arg2 = &temp2;
42842 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42843 }
42844 {
42845 PyThreadState* __tstate = wxPyBeginAllowThreads();
42846 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42847
42848 wxPyEndAllowThreads(__tstate);
42849 if (PyErr_Occurred()) SWIG_fail;
42850 }
42851 {
42852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42853 }
42854 return resultobj;
42855 fail:
42856 return NULL;
42857 }
42858
42859
42860 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42861 PyObject *resultobj = NULL;
42862 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42863 int arg2 = (int) 0 ;
42864 int arg3 = (int) 0 ;
42865 PyObject * obj0 = 0 ;
42866 PyObject * obj1 = 0 ;
42867 PyObject * obj2 = 0 ;
42868 char *kwnames[] = {
42869 (char *) "self",(char *) "row",(char *) "col", NULL
42870 };
42871
42872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42874 if (SWIG_arg_fail(1)) SWIG_fail;
42875 if (obj1) {
42876 {
42877 arg2 = static_cast<int >(SWIG_As_int(obj1));
42878 if (SWIG_arg_fail(2)) SWIG_fail;
42879 }
42880 }
42881 if (obj2) {
42882 {
42883 arg3 = static_cast<int >(SWIG_As_int(obj2));
42884 if (SWIG_arg_fail(3)) SWIG_fail;
42885 }
42886 }
42887 {
42888 PyThreadState* __tstate = wxPyBeginAllowThreads();
42889 wxGBPosition_Set(arg1,arg2,arg3);
42890
42891 wxPyEndAllowThreads(__tstate);
42892 if (PyErr_Occurred()) SWIG_fail;
42893 }
42894 Py_INCREF(Py_None); resultobj = Py_None;
42895 return resultobj;
42896 fail:
42897 return NULL;
42898 }
42899
42900
42901 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42902 PyObject *resultobj = NULL;
42903 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42904 PyObject *result;
42905 PyObject * obj0 = 0 ;
42906 char *kwnames[] = {
42907 (char *) "self", NULL
42908 };
42909
42910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42912 if (SWIG_arg_fail(1)) SWIG_fail;
42913 {
42914 PyThreadState* __tstate = wxPyBeginAllowThreads();
42915 result = (PyObject *)wxGBPosition_Get(arg1);
42916
42917 wxPyEndAllowThreads(__tstate);
42918 if (PyErr_Occurred()) SWIG_fail;
42919 }
42920 resultobj = result;
42921 return resultobj;
42922 fail:
42923 return NULL;
42924 }
42925
42926
42927 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42928 PyObject *obj;
42929 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42930 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42931 Py_INCREF(obj);
42932 return Py_BuildValue((char *)"");
42933 }
42934 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42935 PyObject *resultobj = NULL;
42936 int arg1 = (int) 1 ;
42937 int arg2 = (int) 1 ;
42938 wxGBSpan *result;
42939 PyObject * obj0 = 0 ;
42940 PyObject * obj1 = 0 ;
42941 char *kwnames[] = {
42942 (char *) "rowspan",(char *) "colspan", NULL
42943 };
42944
42945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42946 if (obj0) {
42947 {
42948 arg1 = static_cast<int >(SWIG_As_int(obj0));
42949 if (SWIG_arg_fail(1)) SWIG_fail;
42950 }
42951 }
42952 if (obj1) {
42953 {
42954 arg2 = static_cast<int >(SWIG_As_int(obj1));
42955 if (SWIG_arg_fail(2)) SWIG_fail;
42956 }
42957 }
42958 {
42959 PyThreadState* __tstate = wxPyBeginAllowThreads();
42960 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42961
42962 wxPyEndAllowThreads(__tstate);
42963 if (PyErr_Occurred()) SWIG_fail;
42964 }
42965 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42966 return resultobj;
42967 fail:
42968 return NULL;
42969 }
42970
42971
42972 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42973 PyObject *resultobj = NULL;
42974 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42975 int result;
42976 PyObject * obj0 = 0 ;
42977 char *kwnames[] = {
42978 (char *) "self", NULL
42979 };
42980
42981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42983 if (SWIG_arg_fail(1)) SWIG_fail;
42984 {
42985 PyThreadState* __tstate = wxPyBeginAllowThreads();
42986 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42987
42988 wxPyEndAllowThreads(__tstate);
42989 if (PyErr_Occurred()) SWIG_fail;
42990 }
42991 {
42992 resultobj = SWIG_From_int(static_cast<int >(result));
42993 }
42994 return resultobj;
42995 fail:
42996 return NULL;
42997 }
42998
42999
43000 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
43001 PyObject *resultobj = NULL;
43002 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43003 int result;
43004 PyObject * obj0 = 0 ;
43005 char *kwnames[] = {
43006 (char *) "self", NULL
43007 };
43008
43009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
43010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43011 if (SWIG_arg_fail(1)) SWIG_fail;
43012 {
43013 PyThreadState* __tstate = wxPyBeginAllowThreads();
43014 result = (int)((wxGBSpan const *)arg1)->GetColspan();
43015
43016 wxPyEndAllowThreads(__tstate);
43017 if (PyErr_Occurred()) SWIG_fail;
43018 }
43019 {
43020 resultobj = SWIG_From_int(static_cast<int >(result));
43021 }
43022 return resultobj;
43023 fail:
43024 return NULL;
43025 }
43026
43027
43028 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
43029 PyObject *resultobj = NULL;
43030 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43031 int arg2 ;
43032 PyObject * obj0 = 0 ;
43033 PyObject * obj1 = 0 ;
43034 char *kwnames[] = {
43035 (char *) "self",(char *) "rowspan", NULL
43036 };
43037
43038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
43039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43040 if (SWIG_arg_fail(1)) SWIG_fail;
43041 {
43042 arg2 = static_cast<int >(SWIG_As_int(obj1));
43043 if (SWIG_arg_fail(2)) SWIG_fail;
43044 }
43045 {
43046 PyThreadState* __tstate = wxPyBeginAllowThreads();
43047 (arg1)->SetRowspan(arg2);
43048
43049 wxPyEndAllowThreads(__tstate);
43050 if (PyErr_Occurred()) SWIG_fail;
43051 }
43052 Py_INCREF(Py_None); resultobj = Py_None;
43053 return resultobj;
43054 fail:
43055 return NULL;
43056 }
43057
43058
43059 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
43060 PyObject *resultobj = NULL;
43061 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43062 int arg2 ;
43063 PyObject * obj0 = 0 ;
43064 PyObject * obj1 = 0 ;
43065 char *kwnames[] = {
43066 (char *) "self",(char *) "colspan", NULL
43067 };
43068
43069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
43070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43071 if (SWIG_arg_fail(1)) SWIG_fail;
43072 {
43073 arg2 = static_cast<int >(SWIG_As_int(obj1));
43074 if (SWIG_arg_fail(2)) SWIG_fail;
43075 }
43076 {
43077 PyThreadState* __tstate = wxPyBeginAllowThreads();
43078 (arg1)->SetColspan(arg2);
43079
43080 wxPyEndAllowThreads(__tstate);
43081 if (PyErr_Occurred()) SWIG_fail;
43082 }
43083 Py_INCREF(Py_None); resultobj = Py_None;
43084 return resultobj;
43085 fail:
43086 return NULL;
43087 }
43088
43089
43090 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
43091 PyObject *resultobj = NULL;
43092 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43093 wxGBSpan *arg2 = 0 ;
43094 bool result;
43095 wxGBSpan temp2 ;
43096 PyObject * obj0 = 0 ;
43097 PyObject * obj1 = 0 ;
43098 char *kwnames[] = {
43099 (char *) "self",(char *) "other", NULL
43100 };
43101
43102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
43103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43104 if (SWIG_arg_fail(1)) SWIG_fail;
43105 {
43106 arg2 = &temp2;
43107 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43108 }
43109 {
43110 PyThreadState* __tstate = wxPyBeginAllowThreads();
43111 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
43112
43113 wxPyEndAllowThreads(__tstate);
43114 if (PyErr_Occurred()) SWIG_fail;
43115 }
43116 {
43117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43118 }
43119 return resultobj;
43120 fail:
43121 return NULL;
43122 }
43123
43124
43125 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
43126 PyObject *resultobj = NULL;
43127 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43128 wxGBSpan *arg2 = 0 ;
43129 bool result;
43130 wxGBSpan temp2 ;
43131 PyObject * obj0 = 0 ;
43132 PyObject * obj1 = 0 ;
43133 char *kwnames[] = {
43134 (char *) "self",(char *) "other", NULL
43135 };
43136
43137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
43138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43139 if (SWIG_arg_fail(1)) SWIG_fail;
43140 {
43141 arg2 = &temp2;
43142 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43143 }
43144 {
43145 PyThreadState* __tstate = wxPyBeginAllowThreads();
43146 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
43147
43148 wxPyEndAllowThreads(__tstate);
43149 if (PyErr_Occurred()) SWIG_fail;
43150 }
43151 {
43152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43153 }
43154 return resultobj;
43155 fail:
43156 return NULL;
43157 }
43158
43159
43160 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43161 PyObject *resultobj = NULL;
43162 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43163 int arg2 = (int) 1 ;
43164 int arg3 = (int) 1 ;
43165 PyObject * obj0 = 0 ;
43166 PyObject * obj1 = 0 ;
43167 PyObject * obj2 = 0 ;
43168 char *kwnames[] = {
43169 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
43170 };
43171
43172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
43173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43174 if (SWIG_arg_fail(1)) SWIG_fail;
43175 if (obj1) {
43176 {
43177 arg2 = static_cast<int >(SWIG_As_int(obj1));
43178 if (SWIG_arg_fail(2)) SWIG_fail;
43179 }
43180 }
43181 if (obj2) {
43182 {
43183 arg3 = static_cast<int >(SWIG_As_int(obj2));
43184 if (SWIG_arg_fail(3)) SWIG_fail;
43185 }
43186 }
43187 {
43188 PyThreadState* __tstate = wxPyBeginAllowThreads();
43189 wxGBSpan_Set(arg1,arg2,arg3);
43190
43191 wxPyEndAllowThreads(__tstate);
43192 if (PyErr_Occurred()) SWIG_fail;
43193 }
43194 Py_INCREF(Py_None); resultobj = Py_None;
43195 return resultobj;
43196 fail:
43197 return NULL;
43198 }
43199
43200
43201 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
43202 PyObject *resultobj = NULL;
43203 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43204 PyObject *result;
43205 PyObject * obj0 = 0 ;
43206 char *kwnames[] = {
43207 (char *) "self", NULL
43208 };
43209
43210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
43211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43212 if (SWIG_arg_fail(1)) SWIG_fail;
43213 {
43214 PyThreadState* __tstate = wxPyBeginAllowThreads();
43215 result = (PyObject *)wxGBSpan_Get(arg1);
43216
43217 wxPyEndAllowThreads(__tstate);
43218 if (PyErr_Occurred()) SWIG_fail;
43219 }
43220 resultobj = result;
43221 return resultobj;
43222 fail:
43223 return NULL;
43224 }
43225
43226
43227 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
43228 PyObject *obj;
43229 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43230 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
43231 Py_INCREF(obj);
43232 return Py_BuildValue((char *)"");
43233 }
43234 static int _wrap_DefaultSpan_set(PyObject *) {
43235 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
43236 return 1;
43237 }
43238
43239
43240 static PyObject *_wrap_DefaultSpan_get(void) {
43241 PyObject *pyobj = NULL;
43242
43243 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
43244 return pyobj;
43245 }
43246
43247
43248 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
43249 PyObject *resultobj = NULL;
43250 wxGBSizerItem *result;
43251 char *kwnames[] = {
43252 NULL
43253 };
43254
43255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
43256 {
43257 PyThreadState* __tstate = wxPyBeginAllowThreads();
43258 result = (wxGBSizerItem *)new wxGBSizerItem();
43259
43260 wxPyEndAllowThreads(__tstate);
43261 if (PyErr_Occurred()) SWIG_fail;
43262 }
43263 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43264 return resultobj;
43265 fail:
43266 return NULL;
43267 }
43268
43269
43270 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43271 PyObject *resultobj = NULL;
43272 wxWindow *arg1 = (wxWindow *) 0 ;
43273 wxGBPosition *arg2 = 0 ;
43274 wxGBSpan *arg3 = 0 ;
43275 int arg4 ;
43276 int arg5 ;
43277 PyObject *arg6 = (PyObject *) NULL ;
43278 wxGBSizerItem *result;
43279 wxGBPosition temp2 ;
43280 wxGBSpan temp3 ;
43281 PyObject * obj0 = 0 ;
43282 PyObject * obj1 = 0 ;
43283 PyObject * obj2 = 0 ;
43284 PyObject * obj3 = 0 ;
43285 PyObject * obj4 = 0 ;
43286 PyObject * obj5 = 0 ;
43287 char *kwnames[] = {
43288 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43289 };
43290
43291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43293 if (SWIG_arg_fail(1)) SWIG_fail;
43294 {
43295 arg2 = &temp2;
43296 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43297 }
43298 {
43299 arg3 = &temp3;
43300 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43301 }
43302 {
43303 arg4 = static_cast<int >(SWIG_As_int(obj3));
43304 if (SWIG_arg_fail(4)) SWIG_fail;
43305 }
43306 {
43307 arg5 = static_cast<int >(SWIG_As_int(obj4));
43308 if (SWIG_arg_fail(5)) SWIG_fail;
43309 }
43310 if (obj5) {
43311 arg6 = obj5;
43312 }
43313 {
43314 PyThreadState* __tstate = wxPyBeginAllowThreads();
43315 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43316
43317 wxPyEndAllowThreads(__tstate);
43318 if (PyErr_Occurred()) SWIG_fail;
43319 }
43320 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43321 return resultobj;
43322 fail:
43323 return NULL;
43324 }
43325
43326
43327 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43328 PyObject *resultobj = NULL;
43329 wxSizer *arg1 = (wxSizer *) 0 ;
43330 wxGBPosition *arg2 = 0 ;
43331 wxGBSpan *arg3 = 0 ;
43332 int arg4 ;
43333 int arg5 ;
43334 PyObject *arg6 = (PyObject *) NULL ;
43335 wxGBSizerItem *result;
43336 wxGBPosition temp2 ;
43337 wxGBSpan temp3 ;
43338 PyObject * obj0 = 0 ;
43339 PyObject * obj1 = 0 ;
43340 PyObject * obj2 = 0 ;
43341 PyObject * obj3 = 0 ;
43342 PyObject * obj4 = 0 ;
43343 PyObject * obj5 = 0 ;
43344 char *kwnames[] = {
43345 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43346 };
43347
43348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43350 if (SWIG_arg_fail(1)) SWIG_fail;
43351 {
43352 arg2 = &temp2;
43353 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43354 }
43355 {
43356 arg3 = &temp3;
43357 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43358 }
43359 {
43360 arg4 = static_cast<int >(SWIG_As_int(obj3));
43361 if (SWIG_arg_fail(4)) SWIG_fail;
43362 }
43363 {
43364 arg5 = static_cast<int >(SWIG_As_int(obj4));
43365 if (SWIG_arg_fail(5)) SWIG_fail;
43366 }
43367 if (obj5) {
43368 arg6 = obj5;
43369 }
43370 {
43371 PyThreadState* __tstate = wxPyBeginAllowThreads();
43372 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43373
43374 wxPyEndAllowThreads(__tstate);
43375 if (PyErr_Occurred()) SWIG_fail;
43376 }
43377 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43378 return resultobj;
43379 fail:
43380 return NULL;
43381 }
43382
43383
43384 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
43385 PyObject *resultobj = NULL;
43386 int arg1 ;
43387 int arg2 ;
43388 wxGBPosition *arg3 = 0 ;
43389 wxGBSpan *arg4 = 0 ;
43390 int arg5 ;
43391 int arg6 ;
43392 PyObject *arg7 = (PyObject *) NULL ;
43393 wxGBSizerItem *result;
43394 wxGBPosition temp3 ;
43395 wxGBSpan temp4 ;
43396 PyObject * obj0 = 0 ;
43397 PyObject * obj1 = 0 ;
43398 PyObject * obj2 = 0 ;
43399 PyObject * obj3 = 0 ;
43400 PyObject * obj4 = 0 ;
43401 PyObject * obj5 = 0 ;
43402 PyObject * obj6 = 0 ;
43403 char *kwnames[] = {
43404 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43405 };
43406
43407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43408 {
43409 arg1 = static_cast<int >(SWIG_As_int(obj0));
43410 if (SWIG_arg_fail(1)) SWIG_fail;
43411 }
43412 {
43413 arg2 = static_cast<int >(SWIG_As_int(obj1));
43414 if (SWIG_arg_fail(2)) SWIG_fail;
43415 }
43416 {
43417 arg3 = &temp3;
43418 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43419 }
43420 {
43421 arg4 = &temp4;
43422 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43423 }
43424 {
43425 arg5 = static_cast<int >(SWIG_As_int(obj4));
43426 if (SWIG_arg_fail(5)) SWIG_fail;
43427 }
43428 {
43429 arg6 = static_cast<int >(SWIG_As_int(obj5));
43430 if (SWIG_arg_fail(6)) SWIG_fail;
43431 }
43432 if (obj6) {
43433 arg7 = obj6;
43434 }
43435 {
43436 PyThreadState* __tstate = wxPyBeginAllowThreads();
43437 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43438
43439 wxPyEndAllowThreads(__tstate);
43440 if (PyErr_Occurred()) SWIG_fail;
43441 }
43442 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43443 return resultobj;
43444 fail:
43445 return NULL;
43446 }
43447
43448
43449 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43450 PyObject *resultobj = NULL;
43451 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43452 wxGBPosition result;
43453 PyObject * obj0 = 0 ;
43454 char *kwnames[] = {
43455 (char *) "self", NULL
43456 };
43457
43458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
43459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43460 if (SWIG_arg_fail(1)) SWIG_fail;
43461 {
43462 PyThreadState* __tstate = wxPyBeginAllowThreads();
43463 result = ((wxGBSizerItem const *)arg1)->GetPos();
43464
43465 wxPyEndAllowThreads(__tstate);
43466 if (PyErr_Occurred()) SWIG_fail;
43467 }
43468 {
43469 wxGBPosition * resultptr;
43470 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
43471 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43472 }
43473 return resultobj;
43474 fail:
43475 return NULL;
43476 }
43477
43478
43479 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43480 PyObject *resultobj = NULL;
43481 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43482 wxGBSpan result;
43483 PyObject * obj0 = 0 ;
43484 char *kwnames[] = {
43485 (char *) "self", NULL
43486 };
43487
43488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
43489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43490 if (SWIG_arg_fail(1)) SWIG_fail;
43491 {
43492 PyThreadState* __tstate = wxPyBeginAllowThreads();
43493 result = ((wxGBSizerItem const *)arg1)->GetSpan();
43494
43495 wxPyEndAllowThreads(__tstate);
43496 if (PyErr_Occurred()) SWIG_fail;
43497 }
43498 {
43499 wxGBSpan * resultptr;
43500 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
43501 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43502 }
43503 return resultobj;
43504 fail:
43505 return NULL;
43506 }
43507
43508
43509 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43510 PyObject *resultobj = NULL;
43511 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43512 wxGBPosition *arg2 = 0 ;
43513 bool result;
43514 wxGBPosition temp2 ;
43515 PyObject * obj0 = 0 ;
43516 PyObject * obj1 = 0 ;
43517 char *kwnames[] = {
43518 (char *) "self",(char *) "pos", NULL
43519 };
43520
43521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
43522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43523 if (SWIG_arg_fail(1)) SWIG_fail;
43524 {
43525 arg2 = &temp2;
43526 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43527 }
43528 {
43529 PyThreadState* __tstate = wxPyBeginAllowThreads();
43530 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
43531
43532 wxPyEndAllowThreads(__tstate);
43533 if (PyErr_Occurred()) SWIG_fail;
43534 }
43535 {
43536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43537 }
43538 return resultobj;
43539 fail:
43540 return NULL;
43541 }
43542
43543
43544 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43545 PyObject *resultobj = NULL;
43546 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43547 wxGBSpan *arg2 = 0 ;
43548 bool result;
43549 wxGBSpan temp2 ;
43550 PyObject * obj0 = 0 ;
43551 PyObject * obj1 = 0 ;
43552 char *kwnames[] = {
43553 (char *) "self",(char *) "span", NULL
43554 };
43555
43556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
43557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43558 if (SWIG_arg_fail(1)) SWIG_fail;
43559 {
43560 arg2 = &temp2;
43561 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43562 }
43563 {
43564 PyThreadState* __tstate = wxPyBeginAllowThreads();
43565 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
43566
43567 wxPyEndAllowThreads(__tstate);
43568 if (PyErr_Occurred()) SWIG_fail;
43569 }
43570 {
43571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43572 }
43573 return resultobj;
43574 fail:
43575 return NULL;
43576 }
43577
43578
43579 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
43580 PyObject *resultobj = NULL;
43581 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43582 wxGBSizerItem *arg2 = 0 ;
43583 bool result;
43584 PyObject * obj0 = 0 ;
43585 PyObject * obj1 = 0 ;
43586 char *kwnames[] = {
43587 (char *) "self",(char *) "other", NULL
43588 };
43589
43590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
43591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43592 if (SWIG_arg_fail(1)) SWIG_fail;
43593 {
43594 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43595 if (SWIG_arg_fail(2)) SWIG_fail;
43596 if (arg2 == NULL) {
43597 SWIG_null_ref("wxGBSizerItem");
43598 }
43599 if (SWIG_arg_fail(2)) SWIG_fail;
43600 }
43601 {
43602 PyThreadState* __tstate = wxPyBeginAllowThreads();
43603 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
43604
43605 wxPyEndAllowThreads(__tstate);
43606 if (PyErr_Occurred()) SWIG_fail;
43607 }
43608 {
43609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43610 }
43611 return resultobj;
43612 fail:
43613 return NULL;
43614 }
43615
43616
43617 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
43618 PyObject *resultobj = NULL;
43619 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43620 wxGBPosition *arg2 = 0 ;
43621 wxGBSpan *arg3 = 0 ;
43622 bool result;
43623 wxGBPosition temp2 ;
43624 wxGBSpan temp3 ;
43625 PyObject * obj0 = 0 ;
43626 PyObject * obj1 = 0 ;
43627 PyObject * obj2 = 0 ;
43628 char *kwnames[] = {
43629 (char *) "self",(char *) "pos",(char *) "span", NULL
43630 };
43631
43632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
43633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43634 if (SWIG_arg_fail(1)) SWIG_fail;
43635 {
43636 arg2 = &temp2;
43637 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43638 }
43639 {
43640 arg3 = &temp3;
43641 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43642 }
43643 {
43644 PyThreadState* __tstate = wxPyBeginAllowThreads();
43645 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
43646
43647 wxPyEndAllowThreads(__tstate);
43648 if (PyErr_Occurred()) SWIG_fail;
43649 }
43650 {
43651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43652 }
43653 return resultobj;
43654 fail:
43655 return NULL;
43656 }
43657
43658
43659 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
43660 PyObject *resultobj = NULL;
43661 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43662 wxGBPosition result;
43663 PyObject * obj0 = 0 ;
43664 char *kwnames[] = {
43665 (char *) "self", NULL
43666 };
43667
43668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
43669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43670 if (SWIG_arg_fail(1)) SWIG_fail;
43671 {
43672 PyThreadState* __tstate = wxPyBeginAllowThreads();
43673 result = wxGBSizerItem_GetEndPos(arg1);
43674
43675 wxPyEndAllowThreads(__tstate);
43676 if (PyErr_Occurred()) SWIG_fail;
43677 }
43678 {
43679 wxGBPosition * resultptr;
43680 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
43681 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43682 }
43683 return resultobj;
43684 fail:
43685 return NULL;
43686 }
43687
43688
43689 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43690 PyObject *resultobj = NULL;
43691 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43692 wxGridBagSizer *result;
43693 PyObject * obj0 = 0 ;
43694 char *kwnames[] = {
43695 (char *) "self", NULL
43696 };
43697
43698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
43699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43700 if (SWIG_arg_fail(1)) SWIG_fail;
43701 {
43702 PyThreadState* __tstate = wxPyBeginAllowThreads();
43703 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
43704
43705 wxPyEndAllowThreads(__tstate);
43706 if (PyErr_Occurred()) SWIG_fail;
43707 }
43708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
43709 return resultobj;
43710 fail:
43711 return NULL;
43712 }
43713
43714
43715 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43716 PyObject *resultobj = NULL;
43717 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43718 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
43719 PyObject * obj0 = 0 ;
43720 PyObject * obj1 = 0 ;
43721 char *kwnames[] = {
43722 (char *) "self",(char *) "sizer", NULL
43723 };
43724
43725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
43726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43727 if (SWIG_arg_fail(1)) SWIG_fail;
43728 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43729 if (SWIG_arg_fail(2)) SWIG_fail;
43730 {
43731 PyThreadState* __tstate = wxPyBeginAllowThreads();
43732 (arg1)->SetGBSizer(arg2);
43733
43734 wxPyEndAllowThreads(__tstate);
43735 if (PyErr_Occurred()) SWIG_fail;
43736 }
43737 Py_INCREF(Py_None); resultobj = Py_None;
43738 return resultobj;
43739 fail:
43740 return NULL;
43741 }
43742
43743
43744 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
43745 PyObject *obj;
43746 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43747 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
43748 Py_INCREF(obj);
43749 return Py_BuildValue((char *)"");
43750 }
43751 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43752 PyObject *resultobj = NULL;
43753 int arg1 = (int) 0 ;
43754 int arg2 = (int) 0 ;
43755 wxGridBagSizer *result;
43756 PyObject * obj0 = 0 ;
43757 PyObject * obj1 = 0 ;
43758 char *kwnames[] = {
43759 (char *) "vgap",(char *) "hgap", NULL
43760 };
43761
43762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
43763 if (obj0) {
43764 {
43765 arg1 = static_cast<int >(SWIG_As_int(obj0));
43766 if (SWIG_arg_fail(1)) SWIG_fail;
43767 }
43768 }
43769 if (obj1) {
43770 {
43771 arg2 = static_cast<int >(SWIG_As_int(obj1));
43772 if (SWIG_arg_fail(2)) SWIG_fail;
43773 }
43774 }
43775 {
43776 PyThreadState* __tstate = wxPyBeginAllowThreads();
43777 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
43778
43779 wxPyEndAllowThreads(__tstate);
43780 if (PyErr_Occurred()) SWIG_fail;
43781 }
43782 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
43783 return resultobj;
43784 fail:
43785 return NULL;
43786 }
43787
43788
43789 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
43790 PyObject *resultobj = NULL;
43791 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43792 PyObject *arg2 = (PyObject *) 0 ;
43793 wxGBPosition *arg3 = 0 ;
43794 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
43795 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
43796 int arg5 = (int) 0 ;
43797 int arg6 = (int) 0 ;
43798 PyObject *arg7 = (PyObject *) NULL ;
43799 wxGBSizerItem *result;
43800 wxGBPosition temp3 ;
43801 wxGBSpan temp4 ;
43802 PyObject * obj0 = 0 ;
43803 PyObject * obj1 = 0 ;
43804 PyObject * obj2 = 0 ;
43805 PyObject * obj3 = 0 ;
43806 PyObject * obj4 = 0 ;
43807 PyObject * obj5 = 0 ;
43808 PyObject * obj6 = 0 ;
43809 char *kwnames[] = {
43810 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43811 };
43812
43813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43815 if (SWIG_arg_fail(1)) SWIG_fail;
43816 arg2 = obj1;
43817 {
43818 arg3 = &temp3;
43819 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43820 }
43821 if (obj3) {
43822 {
43823 arg4 = &temp4;
43824 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43825 }
43826 }
43827 if (obj4) {
43828 {
43829 arg5 = static_cast<int >(SWIG_As_int(obj4));
43830 if (SWIG_arg_fail(5)) SWIG_fail;
43831 }
43832 }
43833 if (obj5) {
43834 {
43835 arg6 = static_cast<int >(SWIG_As_int(obj5));
43836 if (SWIG_arg_fail(6)) SWIG_fail;
43837 }
43838 }
43839 if (obj6) {
43840 arg7 = obj6;
43841 }
43842 {
43843 PyThreadState* __tstate = wxPyBeginAllowThreads();
43844 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43845
43846 wxPyEndAllowThreads(__tstate);
43847 if (PyErr_Occurred()) SWIG_fail;
43848 }
43849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43850 return resultobj;
43851 fail:
43852 return NULL;
43853 }
43854
43855
43856 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
43857 PyObject *resultobj = NULL;
43858 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43859 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43860 wxGBSizerItem *result;
43861 PyObject * obj0 = 0 ;
43862 PyObject * obj1 = 0 ;
43863 char *kwnames[] = {
43864 (char *) "self",(char *) "item", NULL
43865 };
43866
43867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
43868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43869 if (SWIG_arg_fail(1)) SWIG_fail;
43870 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43871 if (SWIG_arg_fail(2)) SWIG_fail;
43872 {
43873 PyThreadState* __tstate = wxPyBeginAllowThreads();
43874 result = (wxGBSizerItem *)(arg1)->Add(arg2);
43875
43876 wxPyEndAllowThreads(__tstate);
43877 if (PyErr_Occurred()) SWIG_fail;
43878 }
43879 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43880 return resultobj;
43881 fail:
43882 return NULL;
43883 }
43884
43885
43886 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43887 PyObject *resultobj = NULL;
43888 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43889 int arg2 ;
43890 int arg3 ;
43891 wxSize result;
43892 PyObject * obj0 = 0 ;
43893 PyObject * obj1 = 0 ;
43894 PyObject * obj2 = 0 ;
43895 char *kwnames[] = {
43896 (char *) "self",(char *) "row",(char *) "col", NULL
43897 };
43898
43899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43901 if (SWIG_arg_fail(1)) SWIG_fail;
43902 {
43903 arg2 = static_cast<int >(SWIG_As_int(obj1));
43904 if (SWIG_arg_fail(2)) SWIG_fail;
43905 }
43906 {
43907 arg3 = static_cast<int >(SWIG_As_int(obj2));
43908 if (SWIG_arg_fail(3)) SWIG_fail;
43909 }
43910 {
43911 PyThreadState* __tstate = wxPyBeginAllowThreads();
43912 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43913
43914 wxPyEndAllowThreads(__tstate);
43915 if (PyErr_Occurred()) SWIG_fail;
43916 }
43917 {
43918 wxSize * resultptr;
43919 resultptr = new wxSize(static_cast<wxSize & >(result));
43920 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43921 }
43922 return resultobj;
43923 fail:
43924 return NULL;
43925 }
43926
43927
43928 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43929 PyObject *resultobj = NULL;
43930 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43931 wxSize result;
43932 PyObject * obj0 = 0 ;
43933 char *kwnames[] = {
43934 (char *) "self", NULL
43935 };
43936
43937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43939 if (SWIG_arg_fail(1)) SWIG_fail;
43940 {
43941 PyThreadState* __tstate = wxPyBeginAllowThreads();
43942 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43943
43944 wxPyEndAllowThreads(__tstate);
43945 if (PyErr_Occurred()) SWIG_fail;
43946 }
43947 {
43948 wxSize * resultptr;
43949 resultptr = new wxSize(static_cast<wxSize & >(result));
43950 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43951 }
43952 return resultobj;
43953 fail:
43954 return NULL;
43955 }
43956
43957
43958 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43959 PyObject *resultobj = NULL;
43960 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43961 wxSize *arg2 = 0 ;
43962 wxSize temp2 ;
43963 PyObject * obj0 = 0 ;
43964 PyObject * obj1 = 0 ;
43965 char *kwnames[] = {
43966 (char *) "self",(char *) "sz", NULL
43967 };
43968
43969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43971 if (SWIG_arg_fail(1)) SWIG_fail;
43972 {
43973 arg2 = &temp2;
43974 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43975 }
43976 {
43977 PyThreadState* __tstate = wxPyBeginAllowThreads();
43978 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43979
43980 wxPyEndAllowThreads(__tstate);
43981 if (PyErr_Occurred()) SWIG_fail;
43982 }
43983 Py_INCREF(Py_None); resultobj = Py_None;
43984 return resultobj;
43985 fail:
43986 return NULL;
43987 }
43988
43989
43990 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43991 PyObject *resultobj = NULL;
43992 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43993 wxWindow *arg2 = (wxWindow *) 0 ;
43994 wxGBPosition result;
43995 PyObject * obj0 = 0 ;
43996 PyObject * obj1 = 0 ;
43997
43998 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44000 if (SWIG_arg_fail(1)) SWIG_fail;
44001 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44002 if (SWIG_arg_fail(2)) SWIG_fail;
44003 {
44004 PyThreadState* __tstate = wxPyBeginAllowThreads();
44005 result = (arg1)->GetItemPosition(arg2);
44006
44007 wxPyEndAllowThreads(__tstate);
44008 if (PyErr_Occurred()) SWIG_fail;
44009 }
44010 {
44011 wxGBPosition * resultptr;
44012 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44013 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44014 }
44015 return resultobj;
44016 fail:
44017 return NULL;
44018 }
44019
44020
44021 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
44022 PyObject *resultobj = NULL;
44023 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44024 wxSizer *arg2 = (wxSizer *) 0 ;
44025 wxGBPosition result;
44026 PyObject * obj0 = 0 ;
44027 PyObject * obj1 = 0 ;
44028
44029 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44031 if (SWIG_arg_fail(1)) SWIG_fail;
44032 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44033 if (SWIG_arg_fail(2)) SWIG_fail;
44034 {
44035 PyThreadState* __tstate = wxPyBeginAllowThreads();
44036 result = (arg1)->GetItemPosition(arg2);
44037
44038 wxPyEndAllowThreads(__tstate);
44039 if (PyErr_Occurred()) SWIG_fail;
44040 }
44041 {
44042 wxGBPosition * resultptr;
44043 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44044 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44045 }
44046 return resultobj;
44047 fail:
44048 return NULL;
44049 }
44050
44051
44052 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44053 PyObject *resultobj = NULL;
44054 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44055 size_t arg2 ;
44056 wxGBPosition result;
44057 PyObject * obj0 = 0 ;
44058 PyObject * obj1 = 0 ;
44059
44060 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44062 if (SWIG_arg_fail(1)) SWIG_fail;
44063 {
44064 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44065 if (SWIG_arg_fail(2)) SWIG_fail;
44066 }
44067 {
44068 PyThreadState* __tstate = wxPyBeginAllowThreads();
44069 result = (arg1)->GetItemPosition(arg2);
44070
44071 wxPyEndAllowThreads(__tstate);
44072 if (PyErr_Occurred()) SWIG_fail;
44073 }
44074 {
44075 wxGBPosition * resultptr;
44076 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44077 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44078 }
44079 return resultobj;
44080 fail:
44081 return NULL;
44082 }
44083
44084
44085 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
44086 int argc;
44087 PyObject *argv[3];
44088 int ii;
44089
44090 argc = PyObject_Length(args);
44091 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44092 argv[ii] = PyTuple_GetItem(args,ii);
44093 }
44094 if (argc == 2) {
44095 int _v;
44096 {
44097 void *ptr;
44098 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44099 _v = 0;
44100 PyErr_Clear();
44101 } else {
44102 _v = 1;
44103 }
44104 }
44105 if (_v) {
44106 {
44107 void *ptr;
44108 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44109 _v = 0;
44110 PyErr_Clear();
44111 } else {
44112 _v = 1;
44113 }
44114 }
44115 if (_v) {
44116 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
44117 }
44118 }
44119 }
44120 if (argc == 2) {
44121 int _v;
44122 {
44123 void *ptr;
44124 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44125 _v = 0;
44126 PyErr_Clear();
44127 } else {
44128 _v = 1;
44129 }
44130 }
44131 if (_v) {
44132 {
44133 void *ptr;
44134 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44135 _v = 0;
44136 PyErr_Clear();
44137 } else {
44138 _v = 1;
44139 }
44140 }
44141 if (_v) {
44142 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
44143 }
44144 }
44145 }
44146 if (argc == 2) {
44147 int _v;
44148 {
44149 void *ptr;
44150 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44151 _v = 0;
44152 PyErr_Clear();
44153 } else {
44154 _v = 1;
44155 }
44156 }
44157 if (_v) {
44158 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44159 if (_v) {
44160 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
44161 }
44162 }
44163 }
44164
44165 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
44166 return NULL;
44167 }
44168
44169
44170 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
44171 PyObject *resultobj = NULL;
44172 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44173 wxWindow *arg2 = (wxWindow *) 0 ;
44174 wxGBPosition *arg3 = 0 ;
44175 bool result;
44176 wxGBPosition temp3 ;
44177 PyObject * obj0 = 0 ;
44178 PyObject * obj1 = 0 ;
44179 PyObject * obj2 = 0 ;
44180
44181 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44183 if (SWIG_arg_fail(1)) SWIG_fail;
44184 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44185 if (SWIG_arg_fail(2)) SWIG_fail;
44186 {
44187 arg3 = &temp3;
44188 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44189 }
44190 {
44191 PyThreadState* __tstate = wxPyBeginAllowThreads();
44192 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44193
44194 wxPyEndAllowThreads(__tstate);
44195 if (PyErr_Occurred()) SWIG_fail;
44196 }
44197 {
44198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44199 }
44200 return resultobj;
44201 fail:
44202 return NULL;
44203 }
44204
44205
44206 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
44207 PyObject *resultobj = NULL;
44208 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44209 wxSizer *arg2 = (wxSizer *) 0 ;
44210 wxGBPosition *arg3 = 0 ;
44211 bool result;
44212 wxGBPosition temp3 ;
44213 PyObject * obj0 = 0 ;
44214 PyObject * obj1 = 0 ;
44215 PyObject * obj2 = 0 ;
44216
44217 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44219 if (SWIG_arg_fail(1)) SWIG_fail;
44220 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44221 if (SWIG_arg_fail(2)) SWIG_fail;
44222 {
44223 arg3 = &temp3;
44224 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44225 }
44226 {
44227 PyThreadState* __tstate = wxPyBeginAllowThreads();
44228 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44229
44230 wxPyEndAllowThreads(__tstate);
44231 if (PyErr_Occurred()) SWIG_fail;
44232 }
44233 {
44234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44235 }
44236 return resultobj;
44237 fail:
44238 return NULL;
44239 }
44240
44241
44242 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44243 PyObject *resultobj = NULL;
44244 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44245 size_t arg2 ;
44246 wxGBPosition *arg3 = 0 ;
44247 bool result;
44248 wxGBPosition temp3 ;
44249 PyObject * obj0 = 0 ;
44250 PyObject * obj1 = 0 ;
44251 PyObject * obj2 = 0 ;
44252
44253 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44255 if (SWIG_arg_fail(1)) SWIG_fail;
44256 {
44257 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44258 if (SWIG_arg_fail(2)) SWIG_fail;
44259 }
44260 {
44261 arg3 = &temp3;
44262 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44263 }
44264 {
44265 PyThreadState* __tstate = wxPyBeginAllowThreads();
44266 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44267
44268 wxPyEndAllowThreads(__tstate);
44269 if (PyErr_Occurred()) SWIG_fail;
44270 }
44271 {
44272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44273 }
44274 return resultobj;
44275 fail:
44276 return NULL;
44277 }
44278
44279
44280 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
44281 int argc;
44282 PyObject *argv[4];
44283 int ii;
44284
44285 argc = PyObject_Length(args);
44286 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44287 argv[ii] = PyTuple_GetItem(args,ii);
44288 }
44289 if (argc == 3) {
44290 int _v;
44291 {
44292 void *ptr;
44293 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44294 _v = 0;
44295 PyErr_Clear();
44296 } else {
44297 _v = 1;
44298 }
44299 }
44300 if (_v) {
44301 {
44302 void *ptr;
44303 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44304 _v = 0;
44305 PyErr_Clear();
44306 } else {
44307 _v = 1;
44308 }
44309 }
44310 if (_v) {
44311 {
44312 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44313 }
44314 if (_v) {
44315 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
44316 }
44317 }
44318 }
44319 }
44320 if (argc == 3) {
44321 int _v;
44322 {
44323 void *ptr;
44324 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44325 _v = 0;
44326 PyErr_Clear();
44327 } else {
44328 _v = 1;
44329 }
44330 }
44331 if (_v) {
44332 {
44333 void *ptr;
44334 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44335 _v = 0;
44336 PyErr_Clear();
44337 } else {
44338 _v = 1;
44339 }
44340 }
44341 if (_v) {
44342 {
44343 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44344 }
44345 if (_v) {
44346 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
44347 }
44348 }
44349 }
44350 }
44351 if (argc == 3) {
44352 int _v;
44353 {
44354 void *ptr;
44355 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44356 _v = 0;
44357 PyErr_Clear();
44358 } else {
44359 _v = 1;
44360 }
44361 }
44362 if (_v) {
44363 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44364 if (_v) {
44365 {
44366 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44367 }
44368 if (_v) {
44369 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
44370 }
44371 }
44372 }
44373 }
44374
44375 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
44376 return NULL;
44377 }
44378
44379
44380 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44381 PyObject *resultobj = NULL;
44382 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44383 wxWindow *arg2 = (wxWindow *) 0 ;
44384 wxGBSpan result;
44385 PyObject * obj0 = 0 ;
44386 PyObject * obj1 = 0 ;
44387
44388 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44390 if (SWIG_arg_fail(1)) SWIG_fail;
44391 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44392 if (SWIG_arg_fail(2)) SWIG_fail;
44393 {
44394 PyThreadState* __tstate = wxPyBeginAllowThreads();
44395 result = (arg1)->GetItemSpan(arg2);
44396
44397 wxPyEndAllowThreads(__tstate);
44398 if (PyErr_Occurred()) SWIG_fail;
44399 }
44400 {
44401 wxGBSpan * resultptr;
44402 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44403 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44404 }
44405 return resultobj;
44406 fail:
44407 return NULL;
44408 }
44409
44410
44411 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44412 PyObject *resultobj = NULL;
44413 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44414 wxSizer *arg2 = (wxSizer *) 0 ;
44415 wxGBSpan result;
44416 PyObject * obj0 = 0 ;
44417 PyObject * obj1 = 0 ;
44418
44419 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44421 if (SWIG_arg_fail(1)) SWIG_fail;
44422 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44423 if (SWIG_arg_fail(2)) SWIG_fail;
44424 {
44425 PyThreadState* __tstate = wxPyBeginAllowThreads();
44426 result = (arg1)->GetItemSpan(arg2);
44427
44428 wxPyEndAllowThreads(__tstate);
44429 if (PyErr_Occurred()) SWIG_fail;
44430 }
44431 {
44432 wxGBSpan * resultptr;
44433 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44434 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44435 }
44436 return resultobj;
44437 fail:
44438 return NULL;
44439 }
44440
44441
44442 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44443 PyObject *resultobj = NULL;
44444 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44445 size_t arg2 ;
44446 wxGBSpan result;
44447 PyObject * obj0 = 0 ;
44448 PyObject * obj1 = 0 ;
44449
44450 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44452 if (SWIG_arg_fail(1)) SWIG_fail;
44453 {
44454 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44455 if (SWIG_arg_fail(2)) SWIG_fail;
44456 }
44457 {
44458 PyThreadState* __tstate = wxPyBeginAllowThreads();
44459 result = (arg1)->GetItemSpan(arg2);
44460
44461 wxPyEndAllowThreads(__tstate);
44462 if (PyErr_Occurred()) SWIG_fail;
44463 }
44464 {
44465 wxGBSpan * resultptr;
44466 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44467 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44468 }
44469 return resultobj;
44470 fail:
44471 return NULL;
44472 }
44473
44474
44475 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
44476 int argc;
44477 PyObject *argv[3];
44478 int ii;
44479
44480 argc = PyObject_Length(args);
44481 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44482 argv[ii] = PyTuple_GetItem(args,ii);
44483 }
44484 if (argc == 2) {
44485 int _v;
44486 {
44487 void *ptr;
44488 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44489 _v = 0;
44490 PyErr_Clear();
44491 } else {
44492 _v = 1;
44493 }
44494 }
44495 if (_v) {
44496 {
44497 void *ptr;
44498 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44499 _v = 0;
44500 PyErr_Clear();
44501 } else {
44502 _v = 1;
44503 }
44504 }
44505 if (_v) {
44506 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
44507 }
44508 }
44509 }
44510 if (argc == 2) {
44511 int _v;
44512 {
44513 void *ptr;
44514 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44515 _v = 0;
44516 PyErr_Clear();
44517 } else {
44518 _v = 1;
44519 }
44520 }
44521 if (_v) {
44522 {
44523 void *ptr;
44524 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44525 _v = 0;
44526 PyErr_Clear();
44527 } else {
44528 _v = 1;
44529 }
44530 }
44531 if (_v) {
44532 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
44533 }
44534 }
44535 }
44536 if (argc == 2) {
44537 int _v;
44538 {
44539 void *ptr;
44540 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44541 _v = 0;
44542 PyErr_Clear();
44543 } else {
44544 _v = 1;
44545 }
44546 }
44547 if (_v) {
44548 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44549 if (_v) {
44550 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
44551 }
44552 }
44553 }
44554
44555 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
44556 return NULL;
44557 }
44558
44559
44560 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44561 PyObject *resultobj = NULL;
44562 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44563 wxWindow *arg2 = (wxWindow *) 0 ;
44564 wxGBSpan *arg3 = 0 ;
44565 bool result;
44566 wxGBSpan temp3 ;
44567 PyObject * obj0 = 0 ;
44568 PyObject * obj1 = 0 ;
44569 PyObject * obj2 = 0 ;
44570
44571 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44573 if (SWIG_arg_fail(1)) SWIG_fail;
44574 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44575 if (SWIG_arg_fail(2)) SWIG_fail;
44576 {
44577 arg3 = &temp3;
44578 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44579 }
44580 {
44581 PyThreadState* __tstate = wxPyBeginAllowThreads();
44582 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44583
44584 wxPyEndAllowThreads(__tstate);
44585 if (PyErr_Occurred()) SWIG_fail;
44586 }
44587 {
44588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44589 }
44590 return resultobj;
44591 fail:
44592 return NULL;
44593 }
44594
44595
44596 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44597 PyObject *resultobj = NULL;
44598 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44599 wxSizer *arg2 = (wxSizer *) 0 ;
44600 wxGBSpan *arg3 = 0 ;
44601 bool result;
44602 wxGBSpan temp3 ;
44603 PyObject * obj0 = 0 ;
44604 PyObject * obj1 = 0 ;
44605 PyObject * obj2 = 0 ;
44606
44607 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44609 if (SWIG_arg_fail(1)) SWIG_fail;
44610 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44611 if (SWIG_arg_fail(2)) SWIG_fail;
44612 {
44613 arg3 = &temp3;
44614 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44615 }
44616 {
44617 PyThreadState* __tstate = wxPyBeginAllowThreads();
44618 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44619
44620 wxPyEndAllowThreads(__tstate);
44621 if (PyErr_Occurred()) SWIG_fail;
44622 }
44623 {
44624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44625 }
44626 return resultobj;
44627 fail:
44628 return NULL;
44629 }
44630
44631
44632 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44633 PyObject *resultobj = NULL;
44634 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44635 size_t arg2 ;
44636 wxGBSpan *arg3 = 0 ;
44637 bool result;
44638 wxGBSpan temp3 ;
44639 PyObject * obj0 = 0 ;
44640 PyObject * obj1 = 0 ;
44641 PyObject * obj2 = 0 ;
44642
44643 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44645 if (SWIG_arg_fail(1)) SWIG_fail;
44646 {
44647 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44648 if (SWIG_arg_fail(2)) SWIG_fail;
44649 }
44650 {
44651 arg3 = &temp3;
44652 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44653 }
44654 {
44655 PyThreadState* __tstate = wxPyBeginAllowThreads();
44656 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44657
44658 wxPyEndAllowThreads(__tstate);
44659 if (PyErr_Occurred()) SWIG_fail;
44660 }
44661 {
44662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44663 }
44664 return resultobj;
44665 fail:
44666 return NULL;
44667 }
44668
44669
44670 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
44671 int argc;
44672 PyObject *argv[4];
44673 int ii;
44674
44675 argc = PyObject_Length(args);
44676 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44677 argv[ii] = PyTuple_GetItem(args,ii);
44678 }
44679 if (argc == 3) {
44680 int _v;
44681 {
44682 void *ptr;
44683 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44684 _v = 0;
44685 PyErr_Clear();
44686 } else {
44687 _v = 1;
44688 }
44689 }
44690 if (_v) {
44691 {
44692 void *ptr;
44693 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44694 _v = 0;
44695 PyErr_Clear();
44696 } else {
44697 _v = 1;
44698 }
44699 }
44700 if (_v) {
44701 {
44702 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44703 }
44704 if (_v) {
44705 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
44706 }
44707 }
44708 }
44709 }
44710 if (argc == 3) {
44711 int _v;
44712 {
44713 void *ptr;
44714 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44715 _v = 0;
44716 PyErr_Clear();
44717 } else {
44718 _v = 1;
44719 }
44720 }
44721 if (_v) {
44722 {
44723 void *ptr;
44724 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44725 _v = 0;
44726 PyErr_Clear();
44727 } else {
44728 _v = 1;
44729 }
44730 }
44731 if (_v) {
44732 {
44733 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44734 }
44735 if (_v) {
44736 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
44737 }
44738 }
44739 }
44740 }
44741 if (argc == 3) {
44742 int _v;
44743 {
44744 void *ptr;
44745 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44746 _v = 0;
44747 PyErr_Clear();
44748 } else {
44749 _v = 1;
44750 }
44751 }
44752 if (_v) {
44753 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44754 if (_v) {
44755 {
44756 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44757 }
44758 if (_v) {
44759 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
44760 }
44761 }
44762 }
44763 }
44764
44765 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
44766 return NULL;
44767 }
44768
44769
44770 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
44771 PyObject *resultobj = NULL;
44772 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44773 wxWindow *arg2 = (wxWindow *) 0 ;
44774 wxGBSizerItem *result;
44775 PyObject * obj0 = 0 ;
44776 PyObject * obj1 = 0 ;
44777
44778 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44780 if (SWIG_arg_fail(1)) SWIG_fail;
44781 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44782 if (SWIG_arg_fail(2)) SWIG_fail;
44783 {
44784 PyThreadState* __tstate = wxPyBeginAllowThreads();
44785 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44786
44787 wxPyEndAllowThreads(__tstate);
44788 if (PyErr_Occurred()) SWIG_fail;
44789 }
44790 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44791 return resultobj;
44792 fail:
44793 return NULL;
44794 }
44795
44796
44797 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
44798 PyObject *resultobj = NULL;
44799 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44800 wxSizer *arg2 = (wxSizer *) 0 ;
44801 wxGBSizerItem *result;
44802 PyObject * obj0 = 0 ;
44803 PyObject * obj1 = 0 ;
44804
44805 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44807 if (SWIG_arg_fail(1)) SWIG_fail;
44808 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44809 if (SWIG_arg_fail(2)) SWIG_fail;
44810 {
44811 PyThreadState* __tstate = wxPyBeginAllowThreads();
44812 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44813
44814 wxPyEndAllowThreads(__tstate);
44815 if (PyErr_Occurred()) SWIG_fail;
44816 }
44817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44818 return resultobj;
44819 fail:
44820 return NULL;
44821 }
44822
44823
44824 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
44825 int argc;
44826 PyObject *argv[3];
44827 int ii;
44828
44829 argc = PyObject_Length(args);
44830 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44831 argv[ii] = PyTuple_GetItem(args,ii);
44832 }
44833 if (argc == 2) {
44834 int _v;
44835 {
44836 void *ptr;
44837 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44838 _v = 0;
44839 PyErr_Clear();
44840 } else {
44841 _v = 1;
44842 }
44843 }
44844 if (_v) {
44845 {
44846 void *ptr;
44847 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44848 _v = 0;
44849 PyErr_Clear();
44850 } else {
44851 _v = 1;
44852 }
44853 }
44854 if (_v) {
44855 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
44856 }
44857 }
44858 }
44859 if (argc == 2) {
44860 int _v;
44861 {
44862 void *ptr;
44863 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44864 _v = 0;
44865 PyErr_Clear();
44866 } else {
44867 _v = 1;
44868 }
44869 }
44870 if (_v) {
44871 {
44872 void *ptr;
44873 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44874 _v = 0;
44875 PyErr_Clear();
44876 } else {
44877 _v = 1;
44878 }
44879 }
44880 if (_v) {
44881 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
44882 }
44883 }
44884 }
44885
44886 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44887 return NULL;
44888 }
44889
44890
44891 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44892 PyObject *resultobj = NULL;
44893 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44894 wxGBPosition *arg2 = 0 ;
44895 wxGBSizerItem *result;
44896 wxGBPosition temp2 ;
44897 PyObject * obj0 = 0 ;
44898 PyObject * obj1 = 0 ;
44899 char *kwnames[] = {
44900 (char *) "self",(char *) "pos", NULL
44901 };
44902
44903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44905 if (SWIG_arg_fail(1)) SWIG_fail;
44906 {
44907 arg2 = &temp2;
44908 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44909 }
44910 {
44911 PyThreadState* __tstate = wxPyBeginAllowThreads();
44912 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44913
44914 wxPyEndAllowThreads(__tstate);
44915 if (PyErr_Occurred()) SWIG_fail;
44916 }
44917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44918 return resultobj;
44919 fail:
44920 return NULL;
44921 }
44922
44923
44924 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44925 PyObject *resultobj = NULL;
44926 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44927 wxPoint *arg2 = 0 ;
44928 wxGBSizerItem *result;
44929 wxPoint temp2 ;
44930 PyObject * obj0 = 0 ;
44931 PyObject * obj1 = 0 ;
44932 char *kwnames[] = {
44933 (char *) "self",(char *) "pt", NULL
44934 };
44935
44936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44938 if (SWIG_arg_fail(1)) SWIG_fail;
44939 {
44940 arg2 = &temp2;
44941 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44942 }
44943 {
44944 PyThreadState* __tstate = wxPyBeginAllowThreads();
44945 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44946
44947 wxPyEndAllowThreads(__tstate);
44948 if (PyErr_Occurred()) SWIG_fail;
44949 }
44950 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44951 return resultobj;
44952 fail:
44953 return NULL;
44954 }
44955
44956
44957 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44958 PyObject *resultobj = NULL;
44959 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44960 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44961 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44962 bool result;
44963 PyObject * obj0 = 0 ;
44964 PyObject * obj1 = 0 ;
44965 PyObject * obj2 = 0 ;
44966 char *kwnames[] = {
44967 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44968 };
44969
44970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44972 if (SWIG_arg_fail(1)) SWIG_fail;
44973 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44974 if (SWIG_arg_fail(2)) SWIG_fail;
44975 if (obj2) {
44976 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44977 if (SWIG_arg_fail(3)) SWIG_fail;
44978 }
44979 {
44980 PyThreadState* __tstate = wxPyBeginAllowThreads();
44981 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44982
44983 wxPyEndAllowThreads(__tstate);
44984 if (PyErr_Occurred()) SWIG_fail;
44985 }
44986 {
44987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44988 }
44989 return resultobj;
44990 fail:
44991 return NULL;
44992 }
44993
44994
44995 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44996 PyObject *resultobj = NULL;
44997 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44998 wxGBPosition *arg2 = 0 ;
44999 wxGBSpan *arg3 = 0 ;
45000 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
45001 bool result;
45002 wxGBPosition temp2 ;
45003 wxGBSpan temp3 ;
45004 PyObject * obj0 = 0 ;
45005 PyObject * obj1 = 0 ;
45006 PyObject * obj2 = 0 ;
45007 PyObject * obj3 = 0 ;
45008 char *kwnames[] = {
45009 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
45010 };
45011
45012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45014 if (SWIG_arg_fail(1)) SWIG_fail;
45015 {
45016 arg2 = &temp2;
45017 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
45018 }
45019 {
45020 arg3 = &temp3;
45021 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
45022 }
45023 if (obj3) {
45024 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45025 if (SWIG_arg_fail(4)) SWIG_fail;
45026 }
45027 {
45028 PyThreadState* __tstate = wxPyBeginAllowThreads();
45029 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
45030
45031 wxPyEndAllowThreads(__tstate);
45032 if (PyErr_Occurred()) SWIG_fail;
45033 }
45034 {
45035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45036 }
45037 return resultobj;
45038 fail:
45039 return NULL;
45040 }
45041
45042
45043 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
45044 PyObject *obj;
45045 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45046 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
45047 Py_INCREF(obj);
45048 return Py_BuildValue((char *)"");
45049 }
45050 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
45051 PyObject *resultobj = NULL;
45052 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45053 wxRelationship arg2 ;
45054 wxWindow *arg3 = (wxWindow *) 0 ;
45055 wxEdge arg4 ;
45056 int arg5 = (int) 0 ;
45057 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
45058 PyObject * obj0 = 0 ;
45059 PyObject * obj1 = 0 ;
45060 PyObject * obj2 = 0 ;
45061 PyObject * obj3 = 0 ;
45062 PyObject * obj4 = 0 ;
45063 PyObject * obj5 = 0 ;
45064 char *kwnames[] = {
45065 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
45066 };
45067
45068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
45069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45070 if (SWIG_arg_fail(1)) SWIG_fail;
45071 {
45072 arg2 = static_cast<wxRelationship >(SWIG_As_int(obj1));
45073 if (SWIG_arg_fail(2)) SWIG_fail;
45074 }
45075 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45076 if (SWIG_arg_fail(3)) SWIG_fail;
45077 {
45078 arg4 = static_cast<wxEdge >(SWIG_As_int(obj3));
45079 if (SWIG_arg_fail(4)) SWIG_fail;
45080 }
45081 if (obj4) {
45082 {
45083 arg5 = static_cast<int >(SWIG_As_int(obj4));
45084 if (SWIG_arg_fail(5)) SWIG_fail;
45085 }
45086 }
45087 if (obj5) {
45088 {
45089 arg6 = static_cast<int >(SWIG_As_int(obj5));
45090 if (SWIG_arg_fail(6)) SWIG_fail;
45091 }
45092 }
45093 {
45094 PyThreadState* __tstate = wxPyBeginAllowThreads();
45095 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
45096
45097 wxPyEndAllowThreads(__tstate);
45098 if (PyErr_Occurred()) SWIG_fail;
45099 }
45100 Py_INCREF(Py_None); resultobj = Py_None;
45101 return resultobj;
45102 fail:
45103 return NULL;
45104 }
45105
45106
45107 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
45108 PyObject *resultobj = NULL;
45109 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45110 wxWindow *arg2 = (wxWindow *) 0 ;
45111 int arg3 = (int) 0 ;
45112 PyObject * obj0 = 0 ;
45113 PyObject * obj1 = 0 ;
45114 PyObject * obj2 = 0 ;
45115 char *kwnames[] = {
45116 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45117 };
45118
45119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
45120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45121 if (SWIG_arg_fail(1)) SWIG_fail;
45122 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45123 if (SWIG_arg_fail(2)) SWIG_fail;
45124 if (obj2) {
45125 {
45126 arg3 = static_cast<int >(SWIG_As_int(obj2));
45127 if (SWIG_arg_fail(3)) SWIG_fail;
45128 }
45129 }
45130 {
45131 PyThreadState* __tstate = wxPyBeginAllowThreads();
45132 (arg1)->LeftOf(arg2,arg3);
45133
45134 wxPyEndAllowThreads(__tstate);
45135 if (PyErr_Occurred()) SWIG_fail;
45136 }
45137 Py_INCREF(Py_None); resultobj = Py_None;
45138 return resultobj;
45139 fail:
45140 return NULL;
45141 }
45142
45143
45144 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
45145 PyObject *resultobj = NULL;
45146 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45147 wxWindow *arg2 = (wxWindow *) 0 ;
45148 int arg3 = (int) 0 ;
45149 PyObject * obj0 = 0 ;
45150 PyObject * obj1 = 0 ;
45151 PyObject * obj2 = 0 ;
45152 char *kwnames[] = {
45153 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45154 };
45155
45156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
45157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45158 if (SWIG_arg_fail(1)) SWIG_fail;
45159 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45160 if (SWIG_arg_fail(2)) SWIG_fail;
45161 if (obj2) {
45162 {
45163 arg3 = static_cast<int >(SWIG_As_int(obj2));
45164 if (SWIG_arg_fail(3)) SWIG_fail;
45165 }
45166 }
45167 {
45168 PyThreadState* __tstate = wxPyBeginAllowThreads();
45169 (arg1)->RightOf(arg2,arg3);
45170
45171 wxPyEndAllowThreads(__tstate);
45172 if (PyErr_Occurred()) SWIG_fail;
45173 }
45174 Py_INCREF(Py_None); resultobj = Py_None;
45175 return resultobj;
45176 fail:
45177 return NULL;
45178 }
45179
45180
45181 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
45182 PyObject *resultobj = NULL;
45183 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45184 wxWindow *arg2 = (wxWindow *) 0 ;
45185 int arg3 = (int) 0 ;
45186 PyObject * obj0 = 0 ;
45187 PyObject * obj1 = 0 ;
45188 PyObject * obj2 = 0 ;
45189 char *kwnames[] = {
45190 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45191 };
45192
45193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
45194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45195 if (SWIG_arg_fail(1)) SWIG_fail;
45196 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45197 if (SWIG_arg_fail(2)) SWIG_fail;
45198 if (obj2) {
45199 {
45200 arg3 = static_cast<int >(SWIG_As_int(obj2));
45201 if (SWIG_arg_fail(3)) SWIG_fail;
45202 }
45203 }
45204 {
45205 PyThreadState* __tstate = wxPyBeginAllowThreads();
45206 (arg1)->Above(arg2,arg3);
45207
45208 wxPyEndAllowThreads(__tstate);
45209 if (PyErr_Occurred()) SWIG_fail;
45210 }
45211 Py_INCREF(Py_None); resultobj = Py_None;
45212 return resultobj;
45213 fail:
45214 return NULL;
45215 }
45216
45217
45218 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
45219 PyObject *resultobj = NULL;
45220 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45221 wxWindow *arg2 = (wxWindow *) 0 ;
45222 int arg3 = (int) 0 ;
45223 PyObject * obj0 = 0 ;
45224 PyObject * obj1 = 0 ;
45225 PyObject * obj2 = 0 ;
45226 char *kwnames[] = {
45227 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45228 };
45229
45230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
45231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45232 if (SWIG_arg_fail(1)) SWIG_fail;
45233 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45234 if (SWIG_arg_fail(2)) SWIG_fail;
45235 if (obj2) {
45236 {
45237 arg3 = static_cast<int >(SWIG_As_int(obj2));
45238 if (SWIG_arg_fail(3)) SWIG_fail;
45239 }
45240 }
45241 {
45242 PyThreadState* __tstate = wxPyBeginAllowThreads();
45243 (arg1)->Below(arg2,arg3);
45244
45245 wxPyEndAllowThreads(__tstate);
45246 if (PyErr_Occurred()) SWIG_fail;
45247 }
45248 Py_INCREF(Py_None); resultobj = Py_None;
45249 return resultobj;
45250 fail:
45251 return NULL;
45252 }
45253
45254
45255 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
45256 PyObject *resultobj = NULL;
45257 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45258 wxWindow *arg2 = (wxWindow *) 0 ;
45259 wxEdge arg3 ;
45260 int arg4 = (int) 0 ;
45261 PyObject * obj0 = 0 ;
45262 PyObject * obj1 = 0 ;
45263 PyObject * obj2 = 0 ;
45264 PyObject * obj3 = 0 ;
45265 char *kwnames[] = {
45266 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
45267 };
45268
45269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45271 if (SWIG_arg_fail(1)) SWIG_fail;
45272 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45273 if (SWIG_arg_fail(2)) SWIG_fail;
45274 {
45275 arg3 = static_cast<wxEdge >(SWIG_As_int(obj2));
45276 if (SWIG_arg_fail(3)) SWIG_fail;
45277 }
45278 if (obj3) {
45279 {
45280 arg4 = static_cast<int >(SWIG_As_int(obj3));
45281 if (SWIG_arg_fail(4)) SWIG_fail;
45282 }
45283 }
45284 {
45285 PyThreadState* __tstate = wxPyBeginAllowThreads();
45286 (arg1)->SameAs(arg2,arg3,arg4);
45287
45288 wxPyEndAllowThreads(__tstate);
45289 if (PyErr_Occurred()) SWIG_fail;
45290 }
45291 Py_INCREF(Py_None); resultobj = Py_None;
45292 return resultobj;
45293 fail:
45294 return NULL;
45295 }
45296
45297
45298 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
45299 PyObject *resultobj = NULL;
45300 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45301 wxWindow *arg2 = (wxWindow *) 0 ;
45302 wxEdge arg3 ;
45303 int arg4 ;
45304 PyObject * obj0 = 0 ;
45305 PyObject * obj1 = 0 ;
45306 PyObject * obj2 = 0 ;
45307 PyObject * obj3 = 0 ;
45308 char *kwnames[] = {
45309 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
45310 };
45311
45312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45314 if (SWIG_arg_fail(1)) SWIG_fail;
45315 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45316 if (SWIG_arg_fail(2)) SWIG_fail;
45317 {
45318 arg3 = static_cast<wxEdge >(SWIG_As_int(obj2));
45319 if (SWIG_arg_fail(3)) SWIG_fail;
45320 }
45321 {
45322 arg4 = static_cast<int >(SWIG_As_int(obj3));
45323 if (SWIG_arg_fail(4)) SWIG_fail;
45324 }
45325 {
45326 PyThreadState* __tstate = wxPyBeginAllowThreads();
45327 (arg1)->PercentOf(arg2,arg3,arg4);
45328
45329 wxPyEndAllowThreads(__tstate);
45330 if (PyErr_Occurred()) SWIG_fail;
45331 }
45332 Py_INCREF(Py_None); resultobj = Py_None;
45333 return resultobj;
45334 fail:
45335 return NULL;
45336 }
45337
45338
45339 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
45340 PyObject *resultobj = NULL;
45341 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45342 int arg2 ;
45343 PyObject * obj0 = 0 ;
45344 PyObject * obj1 = 0 ;
45345 char *kwnames[] = {
45346 (char *) "self",(char *) "val", NULL
45347 };
45348
45349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
45350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45351 if (SWIG_arg_fail(1)) SWIG_fail;
45352 {
45353 arg2 = static_cast<int >(SWIG_As_int(obj1));
45354 if (SWIG_arg_fail(2)) SWIG_fail;
45355 }
45356 {
45357 PyThreadState* __tstate = wxPyBeginAllowThreads();
45358 (arg1)->Absolute(arg2);
45359
45360 wxPyEndAllowThreads(__tstate);
45361 if (PyErr_Occurred()) SWIG_fail;
45362 }
45363 Py_INCREF(Py_None); resultobj = Py_None;
45364 return resultobj;
45365 fail:
45366 return NULL;
45367 }
45368
45369
45370 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
45371 PyObject *resultobj = NULL;
45372 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45373 PyObject * obj0 = 0 ;
45374 char *kwnames[] = {
45375 (char *) "self", NULL
45376 };
45377
45378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
45379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45380 if (SWIG_arg_fail(1)) SWIG_fail;
45381 {
45382 PyThreadState* __tstate = wxPyBeginAllowThreads();
45383 (arg1)->Unconstrained();
45384
45385 wxPyEndAllowThreads(__tstate);
45386 if (PyErr_Occurred()) SWIG_fail;
45387 }
45388 Py_INCREF(Py_None); resultobj = Py_None;
45389 return resultobj;
45390 fail:
45391 return NULL;
45392 }
45393
45394
45395 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
45396 PyObject *resultobj = NULL;
45397 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45398 PyObject * obj0 = 0 ;
45399 char *kwnames[] = {
45400 (char *) "self", NULL
45401 };
45402
45403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
45404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45405 if (SWIG_arg_fail(1)) SWIG_fail;
45406 {
45407 PyThreadState* __tstate = wxPyBeginAllowThreads();
45408 (arg1)->AsIs();
45409
45410 wxPyEndAllowThreads(__tstate);
45411 if (PyErr_Occurred()) SWIG_fail;
45412 }
45413 Py_INCREF(Py_None); resultobj = Py_None;
45414 return resultobj;
45415 fail:
45416 return NULL;
45417 }
45418
45419
45420 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
45421 PyObject *resultobj = NULL;
45422 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45423 wxWindow *result;
45424 PyObject * obj0 = 0 ;
45425 char *kwnames[] = {
45426 (char *) "self", NULL
45427 };
45428
45429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
45430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45431 if (SWIG_arg_fail(1)) SWIG_fail;
45432 {
45433 PyThreadState* __tstate = wxPyBeginAllowThreads();
45434 result = (wxWindow *)(arg1)->GetOtherWindow();
45435
45436 wxPyEndAllowThreads(__tstate);
45437 if (PyErr_Occurred()) SWIG_fail;
45438 }
45439 {
45440 resultobj = wxPyMake_wxObject(result, 0);
45441 }
45442 return resultobj;
45443 fail:
45444 return NULL;
45445 }
45446
45447
45448 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45449 PyObject *resultobj = NULL;
45450 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45451 wxEdge result;
45452 PyObject * obj0 = 0 ;
45453 char *kwnames[] = {
45454 (char *) "self", NULL
45455 };
45456
45457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
45458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45459 if (SWIG_arg_fail(1)) SWIG_fail;
45460 {
45461 PyThreadState* __tstate = wxPyBeginAllowThreads();
45462 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
45463
45464 wxPyEndAllowThreads(__tstate);
45465 if (PyErr_Occurred()) SWIG_fail;
45466 }
45467 resultobj = SWIG_From_int((result));
45468 return resultobj;
45469 fail:
45470 return NULL;
45471 }
45472
45473
45474 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45475 PyObject *resultobj = NULL;
45476 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45477 wxEdge arg2 ;
45478 PyObject * obj0 = 0 ;
45479 PyObject * obj1 = 0 ;
45480 char *kwnames[] = {
45481 (char *) "self",(char *) "which", NULL
45482 };
45483
45484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
45485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45486 if (SWIG_arg_fail(1)) SWIG_fail;
45487 {
45488 arg2 = static_cast<wxEdge >(SWIG_As_int(obj1));
45489 if (SWIG_arg_fail(2)) SWIG_fail;
45490 }
45491 {
45492 PyThreadState* __tstate = wxPyBeginAllowThreads();
45493 (arg1)->SetEdge(arg2);
45494
45495 wxPyEndAllowThreads(__tstate);
45496 if (PyErr_Occurred()) SWIG_fail;
45497 }
45498 Py_INCREF(Py_None); resultobj = Py_None;
45499 return resultobj;
45500 fail:
45501 return NULL;
45502 }
45503
45504
45505 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45506 PyObject *resultobj = NULL;
45507 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45508 int arg2 ;
45509 PyObject * obj0 = 0 ;
45510 PyObject * obj1 = 0 ;
45511 char *kwnames[] = {
45512 (char *) "self",(char *) "v", NULL
45513 };
45514
45515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
45516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45517 if (SWIG_arg_fail(1)) SWIG_fail;
45518 {
45519 arg2 = static_cast<int >(SWIG_As_int(obj1));
45520 if (SWIG_arg_fail(2)) SWIG_fail;
45521 }
45522 {
45523 PyThreadState* __tstate = wxPyBeginAllowThreads();
45524 (arg1)->SetValue(arg2);
45525
45526 wxPyEndAllowThreads(__tstate);
45527 if (PyErr_Occurred()) SWIG_fail;
45528 }
45529 Py_INCREF(Py_None); resultobj = Py_None;
45530 return resultobj;
45531 fail:
45532 return NULL;
45533 }
45534
45535
45536 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45537 PyObject *resultobj = NULL;
45538 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45539 int result;
45540 PyObject * obj0 = 0 ;
45541 char *kwnames[] = {
45542 (char *) "self", NULL
45543 };
45544
45545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
45546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45547 if (SWIG_arg_fail(1)) SWIG_fail;
45548 {
45549 PyThreadState* __tstate = wxPyBeginAllowThreads();
45550 result = (int)(arg1)->GetMargin();
45551
45552 wxPyEndAllowThreads(__tstate);
45553 if (PyErr_Occurred()) SWIG_fail;
45554 }
45555 {
45556 resultobj = SWIG_From_int(static_cast<int >(result));
45557 }
45558 return resultobj;
45559 fail:
45560 return NULL;
45561 }
45562
45563
45564 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45565 PyObject *resultobj = NULL;
45566 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45567 int arg2 ;
45568 PyObject * obj0 = 0 ;
45569 PyObject * obj1 = 0 ;
45570 char *kwnames[] = {
45571 (char *) "self",(char *) "m", NULL
45572 };
45573
45574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
45575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45576 if (SWIG_arg_fail(1)) SWIG_fail;
45577 {
45578 arg2 = static_cast<int >(SWIG_As_int(obj1));
45579 if (SWIG_arg_fail(2)) SWIG_fail;
45580 }
45581 {
45582 PyThreadState* __tstate = wxPyBeginAllowThreads();
45583 (arg1)->SetMargin(arg2);
45584
45585 wxPyEndAllowThreads(__tstate);
45586 if (PyErr_Occurred()) SWIG_fail;
45587 }
45588 Py_INCREF(Py_None); resultobj = Py_None;
45589 return resultobj;
45590 fail:
45591 return NULL;
45592 }
45593
45594
45595 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45596 PyObject *resultobj = NULL;
45597 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45598 int result;
45599 PyObject * obj0 = 0 ;
45600 char *kwnames[] = {
45601 (char *) "self", NULL
45602 };
45603
45604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
45605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45606 if (SWIG_arg_fail(1)) SWIG_fail;
45607 {
45608 PyThreadState* __tstate = wxPyBeginAllowThreads();
45609 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
45610
45611 wxPyEndAllowThreads(__tstate);
45612 if (PyErr_Occurred()) SWIG_fail;
45613 }
45614 {
45615 resultobj = SWIG_From_int(static_cast<int >(result));
45616 }
45617 return resultobj;
45618 fail:
45619 return NULL;
45620 }
45621
45622
45623 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
45624 PyObject *resultobj = NULL;
45625 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45626 int result;
45627 PyObject * obj0 = 0 ;
45628 char *kwnames[] = {
45629 (char *) "self", NULL
45630 };
45631
45632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
45633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45634 if (SWIG_arg_fail(1)) SWIG_fail;
45635 {
45636 PyThreadState* __tstate = wxPyBeginAllowThreads();
45637 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
45638
45639 wxPyEndAllowThreads(__tstate);
45640 if (PyErr_Occurred()) SWIG_fail;
45641 }
45642 {
45643 resultobj = SWIG_From_int(static_cast<int >(result));
45644 }
45645 return resultobj;
45646 fail:
45647 return NULL;
45648 }
45649
45650
45651 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45652 PyObject *resultobj = NULL;
45653 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45654 int result;
45655 PyObject * obj0 = 0 ;
45656 char *kwnames[] = {
45657 (char *) "self", NULL
45658 };
45659
45660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
45661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45662 if (SWIG_arg_fail(1)) SWIG_fail;
45663 {
45664 PyThreadState* __tstate = wxPyBeginAllowThreads();
45665 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
45666
45667 wxPyEndAllowThreads(__tstate);
45668 if (PyErr_Occurred()) SWIG_fail;
45669 }
45670 {
45671 resultobj = SWIG_From_int(static_cast<int >(result));
45672 }
45673 return resultobj;
45674 fail:
45675 return NULL;
45676 }
45677
45678
45679 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45680 PyObject *resultobj = NULL;
45681 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45682 bool result;
45683 PyObject * obj0 = 0 ;
45684 char *kwnames[] = {
45685 (char *) "self", NULL
45686 };
45687
45688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
45689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45690 if (SWIG_arg_fail(1)) SWIG_fail;
45691 {
45692 PyThreadState* __tstate = wxPyBeginAllowThreads();
45693 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
45694
45695 wxPyEndAllowThreads(__tstate);
45696 if (PyErr_Occurred()) SWIG_fail;
45697 }
45698 {
45699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45700 }
45701 return resultobj;
45702 fail:
45703 return NULL;
45704 }
45705
45706
45707 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45708 PyObject *resultobj = NULL;
45709 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45710 bool arg2 ;
45711 PyObject * obj0 = 0 ;
45712 PyObject * obj1 = 0 ;
45713 char *kwnames[] = {
45714 (char *) "self",(char *) "d", NULL
45715 };
45716
45717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
45718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45719 if (SWIG_arg_fail(1)) SWIG_fail;
45720 {
45721 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
45722 if (SWIG_arg_fail(2)) SWIG_fail;
45723 }
45724 {
45725 PyThreadState* __tstate = wxPyBeginAllowThreads();
45726 (arg1)->SetDone(arg2);
45727
45728 wxPyEndAllowThreads(__tstate);
45729 if (PyErr_Occurred()) SWIG_fail;
45730 }
45731 Py_INCREF(Py_None); resultobj = Py_None;
45732 return resultobj;
45733 fail:
45734 return NULL;
45735 }
45736
45737
45738 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45739 PyObject *resultobj = NULL;
45740 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45741 wxRelationship result;
45742 PyObject * obj0 = 0 ;
45743 char *kwnames[] = {
45744 (char *) "self", NULL
45745 };
45746
45747 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
45748 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45749 if (SWIG_arg_fail(1)) SWIG_fail;
45750 {
45751 PyThreadState* __tstate = wxPyBeginAllowThreads();
45752 result = (wxRelationship)(arg1)->GetRelationship();
45753
45754 wxPyEndAllowThreads(__tstate);
45755 if (PyErr_Occurred()) SWIG_fail;
45756 }
45757 resultobj = SWIG_From_int((result));
45758 return resultobj;
45759 fail:
45760 return NULL;
45761 }
45762
45763
45764 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45765 PyObject *resultobj = NULL;
45766 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45767 wxRelationship arg2 ;
45768 PyObject * obj0 = 0 ;
45769 PyObject * obj1 = 0 ;
45770 char *kwnames[] = {
45771 (char *) "self",(char *) "r", NULL
45772 };
45773
45774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
45775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45776 if (SWIG_arg_fail(1)) SWIG_fail;
45777 {
45778 arg2 = static_cast<wxRelationship >(SWIG_As_int(obj1));
45779 if (SWIG_arg_fail(2)) SWIG_fail;
45780 }
45781 {
45782 PyThreadState* __tstate = wxPyBeginAllowThreads();
45783 (arg1)->SetRelationship(arg2);
45784
45785 wxPyEndAllowThreads(__tstate);
45786 if (PyErr_Occurred()) SWIG_fail;
45787 }
45788 Py_INCREF(Py_None); resultobj = Py_None;
45789 return resultobj;
45790 fail:
45791 return NULL;
45792 }
45793
45794
45795 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
45796 PyObject *resultobj = NULL;
45797 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45798 wxWindow *arg2 = (wxWindow *) 0 ;
45799 bool result;
45800 PyObject * obj0 = 0 ;
45801 PyObject * obj1 = 0 ;
45802 char *kwnames[] = {
45803 (char *) "self",(char *) "otherW", NULL
45804 };
45805
45806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
45807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45808 if (SWIG_arg_fail(1)) SWIG_fail;
45809 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45810 if (SWIG_arg_fail(2)) SWIG_fail;
45811 {
45812 PyThreadState* __tstate = wxPyBeginAllowThreads();
45813 result = (bool)(arg1)->ResetIfWin(arg2);
45814
45815 wxPyEndAllowThreads(__tstate);
45816 if (PyErr_Occurred()) SWIG_fail;
45817 }
45818 {
45819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45820 }
45821 return resultobj;
45822 fail:
45823 return NULL;
45824 }
45825
45826
45827 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
45828 PyObject *resultobj = NULL;
45829 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45830 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
45831 wxWindow *arg3 = (wxWindow *) 0 ;
45832 bool result;
45833 PyObject * obj0 = 0 ;
45834 PyObject * obj1 = 0 ;
45835 PyObject * obj2 = 0 ;
45836 char *kwnames[] = {
45837 (char *) "self",(char *) "constraints",(char *) "win", NULL
45838 };
45839
45840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
45841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45842 if (SWIG_arg_fail(1)) SWIG_fail;
45843 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45844 if (SWIG_arg_fail(2)) SWIG_fail;
45845 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45846 if (SWIG_arg_fail(3)) SWIG_fail;
45847 {
45848 PyThreadState* __tstate = wxPyBeginAllowThreads();
45849 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
45850
45851 wxPyEndAllowThreads(__tstate);
45852 if (PyErr_Occurred()) SWIG_fail;
45853 }
45854 {
45855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45856 }
45857 return resultobj;
45858 fail:
45859 return NULL;
45860 }
45861
45862
45863 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45864 PyObject *resultobj = NULL;
45865 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45866 wxEdge arg2 ;
45867 wxWindow *arg3 = (wxWindow *) 0 ;
45868 wxWindow *arg4 = (wxWindow *) 0 ;
45869 int result;
45870 PyObject * obj0 = 0 ;
45871 PyObject * obj1 = 0 ;
45872 PyObject * obj2 = 0 ;
45873 PyObject * obj3 = 0 ;
45874 char *kwnames[] = {
45875 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
45876 };
45877
45878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45880 if (SWIG_arg_fail(1)) SWIG_fail;
45881 {
45882 arg2 = static_cast<wxEdge >(SWIG_As_int(obj1));
45883 if (SWIG_arg_fail(2)) SWIG_fail;
45884 }
45885 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45886 if (SWIG_arg_fail(3)) SWIG_fail;
45887 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45888 if (SWIG_arg_fail(4)) SWIG_fail;
45889 {
45890 PyThreadState* __tstate = wxPyBeginAllowThreads();
45891 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
45892
45893 wxPyEndAllowThreads(__tstate);
45894 if (PyErr_Occurred()) SWIG_fail;
45895 }
45896 {
45897 resultobj = SWIG_From_int(static_cast<int >(result));
45898 }
45899 return resultobj;
45900 fail:
45901 return NULL;
45902 }
45903
45904
45905 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45906 PyObject *obj;
45907 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45908 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45909 Py_INCREF(obj);
45910 return Py_BuildValue((char *)"");
45911 }
45912 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45913 PyObject *resultobj = NULL;
45914 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45915 wxIndividualLayoutConstraint *result;
45916 PyObject * obj0 = 0 ;
45917 char *kwnames[] = {
45918 (char *) "self", NULL
45919 };
45920
45921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45923 if (SWIG_arg_fail(1)) SWIG_fail;
45924 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45925
45926 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45927 return resultobj;
45928 fail:
45929 return NULL;
45930 }
45931
45932
45933 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45934 PyObject *resultobj = NULL;
45935 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45936 wxIndividualLayoutConstraint *result;
45937 PyObject * obj0 = 0 ;
45938 char *kwnames[] = {
45939 (char *) "self", NULL
45940 };
45941
45942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45944 if (SWIG_arg_fail(1)) SWIG_fail;
45945 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45946
45947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45948 return resultobj;
45949 fail:
45950 return NULL;
45951 }
45952
45953
45954 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45955 PyObject *resultobj = NULL;
45956 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45957 wxIndividualLayoutConstraint *result;
45958 PyObject * obj0 = 0 ;
45959 char *kwnames[] = {
45960 (char *) "self", NULL
45961 };
45962
45963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45965 if (SWIG_arg_fail(1)) SWIG_fail;
45966 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45967
45968 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45969 return resultobj;
45970 fail:
45971 return NULL;
45972 }
45973
45974
45975 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45976 PyObject *resultobj = NULL;
45977 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45978 wxIndividualLayoutConstraint *result;
45979 PyObject * obj0 = 0 ;
45980 char *kwnames[] = {
45981 (char *) "self", NULL
45982 };
45983
45984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45986 if (SWIG_arg_fail(1)) SWIG_fail;
45987 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45988
45989 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45990 return resultobj;
45991 fail:
45992 return NULL;
45993 }
45994
45995
45996 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45997 PyObject *resultobj = NULL;
45998 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45999 wxIndividualLayoutConstraint *result;
46000 PyObject * obj0 = 0 ;
46001 char *kwnames[] = {
46002 (char *) "self", NULL
46003 };
46004
46005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
46006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46007 if (SWIG_arg_fail(1)) SWIG_fail;
46008 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
46009
46010 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46011 return resultobj;
46012 fail:
46013 return NULL;
46014 }
46015
46016
46017 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
46018 PyObject *resultobj = NULL;
46019 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46020 wxIndividualLayoutConstraint *result;
46021 PyObject * obj0 = 0 ;
46022 char *kwnames[] = {
46023 (char *) "self", NULL
46024 };
46025
46026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
46027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46028 if (SWIG_arg_fail(1)) SWIG_fail;
46029 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
46030
46031 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46032 return resultobj;
46033 fail:
46034 return NULL;
46035 }
46036
46037
46038 static PyObject *_wrap_LayoutConstraints_centreX_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_centreX_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)->centreX);
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_centreY_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_centreY_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)->centreY);
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_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
46081 PyObject *resultobj = NULL;
46082 wxLayoutConstraints *result;
46083 char *kwnames[] = {
46084 NULL
46085 };
46086
46087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
46088 {
46089 PyThreadState* __tstate = wxPyBeginAllowThreads();
46090 result = (wxLayoutConstraints *)new wxLayoutConstraints();
46091
46092 wxPyEndAllowThreads(__tstate);
46093 if (PyErr_Occurred()) SWIG_fail;
46094 }
46095 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
46096 return resultobj;
46097 fail:
46098 return NULL;
46099 }
46100
46101
46102 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
46103 PyObject *resultobj = NULL;
46104 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46105 wxWindow *arg2 = (wxWindow *) 0 ;
46106 int *arg3 = (int *) 0 ;
46107 bool result;
46108 int temp3 ;
46109 int res3 = 0 ;
46110 PyObject * obj0 = 0 ;
46111 PyObject * obj1 = 0 ;
46112 char *kwnames[] = {
46113 (char *) "self",(char *) "win", NULL
46114 };
46115
46116 arg3 = &temp3; res3 = SWIG_NEWOBJ;
46117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
46118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46119 if (SWIG_arg_fail(1)) SWIG_fail;
46120 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46121 if (SWIG_arg_fail(2)) SWIG_fail;
46122 {
46123 PyThreadState* __tstate = wxPyBeginAllowThreads();
46124 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
46125
46126 wxPyEndAllowThreads(__tstate);
46127 if (PyErr_Occurred()) SWIG_fail;
46128 }
46129 {
46130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46131 }
46132 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
46133 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
46134 return resultobj;
46135 fail:
46136 return NULL;
46137 }
46138
46139
46140 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
46141 PyObject *resultobj = NULL;
46142 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46143 bool result;
46144 PyObject * obj0 = 0 ;
46145 char *kwnames[] = {
46146 (char *) "self", NULL
46147 };
46148
46149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
46150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46151 if (SWIG_arg_fail(1)) SWIG_fail;
46152 {
46153 PyThreadState* __tstate = wxPyBeginAllowThreads();
46154 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
46155
46156 wxPyEndAllowThreads(__tstate);
46157 if (PyErr_Occurred()) SWIG_fail;
46158 }
46159 {
46160 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46161 }
46162 return resultobj;
46163 fail:
46164 return NULL;
46165 }
46166
46167
46168 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
46169 PyObject *obj;
46170 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
46171 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
46172 Py_INCREF(obj);
46173 return Py_BuildValue((char *)"");
46174 }
46175 static PyMethodDef SwigMethods[] = {
46176 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
46177 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
46178 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
46181 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
46202 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
46215 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
46230 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
46284 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
46312 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
46331 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
46333 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
46341 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
46342 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
46354 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
46366 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
46370 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
46376 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
46386 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
46396 { (char *)"new_PyImageHandler", (PyCFunction) _wrap_new_PyImageHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
46399 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
46406 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"Image_RGBValue_red_set", (PyCFunction) _wrap_Image_RGBValue_red_set, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"Image_RGBValue_red_get", (PyCFunction) _wrap_Image_RGBValue_red_get, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"Image_RGBValue_green_set", (PyCFunction) _wrap_Image_RGBValue_green_set, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"Image_RGBValue_green_get", (PyCFunction) _wrap_Image_RGBValue_green_get, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"Image_RGBValue_blue_set", (PyCFunction) _wrap_Image_RGBValue_blue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"Image_RGBValue_blue_get", (PyCFunction) _wrap_Image_RGBValue_blue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
46414 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"Image_HSVValue_hue_set", (PyCFunction) _wrap_Image_HSVValue_hue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"Image_HSVValue_hue_get", (PyCFunction) _wrap_Image_HSVValue_hue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"Image_HSVValue_saturation_set", (PyCFunction) _wrap_Image_HSVValue_saturation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"Image_HSVValue_saturation_get", (PyCFunction) _wrap_Image_HSVValue_saturation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"Image_HSVValue_value_set", (PyCFunction) _wrap_Image_HSVValue_value_set, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"Image_HSVValue_value_get", (PyCFunction) _wrap_Image_HSVValue_value_get, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
46422 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
46506 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
46508 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
46510 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
46512 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
46514 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
46516 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
46518 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
46520 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
46522 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
46524 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
46526 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
46528 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
46530 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
46544 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
46562 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
46565 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
46568 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
46580 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
46585 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
46591 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
46597 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
46603 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46604 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
46612 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46617 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
46624 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
46626 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
46634 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46636 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46638 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46639 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46640 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46642 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46643 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46644 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46645 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46646 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46647 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46648 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46649 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46650 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46651 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46652 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46653 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46654 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46655 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
46656 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
46657 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
46658 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
46659 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
46660 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46661 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46662 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46663 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46664 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46665 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46666 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
46667 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46668 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46669 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46670 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46671 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46672 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46673 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
46674 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46675 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46676 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46677 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46678 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46679 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46680 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46681 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46682 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46683 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46684 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46685 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46686 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46687 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46688 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46689 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46690 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46691 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46692 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46693 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46694 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46695 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46696 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46697 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46698 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46699 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46700 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
46701 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
46702 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
46703 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46704 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46705 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46706 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46707 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46708 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
46709 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
46710 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
46711 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
46712 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
46713 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46714 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46715 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46716 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46717 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46718 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
46719 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46720 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
46721 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46722 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
46723 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46724 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
46725 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
46726 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46727 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46728 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46729 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
46730 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46731 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46732 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
46733 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46734 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46735 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
46736 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46737 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
46738 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46739 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
46740 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
46741 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46742 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
46743 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46744 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46745 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46746 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46747 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46748 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46749 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46750 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
46751 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46752 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46753 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46754 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
46755 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46756 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
46757 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
46758 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46759 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
46760 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46761 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46762 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46763 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
46764 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46765 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46766 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46767 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46768 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
46769 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46770 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46771 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46772 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46773 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46774 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46775 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46776 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
46777 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
46778 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46779 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46780 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
46781 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46782 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
46783 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46784 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46785 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
46786 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46787 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
46788 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46789 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46790 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46791 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
46792 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46793 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46794 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46795 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
46796 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46797 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46798 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46799 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46800 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46801 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46802 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46803 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46804 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46805 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46806 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
46807 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46808 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46809 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
46810 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46811 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46812 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
46813 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46814 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46815 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46816 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
46817 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46818 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
46819 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
46820 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46821 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46822 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
46823 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
46824 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46825 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46826 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46827 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46828 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
46829 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46830 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46831 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46832 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46833 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
46834 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46835 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46836 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46837 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
46838 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46839 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46840 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46841 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46842 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46843 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46844 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46845 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46846 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46847 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
46848 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46849 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46850 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46851 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46852 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46853 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46854 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46855 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46856 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46857 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46858 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46859 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
46860 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46861 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46862 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46863 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46864 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46865 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46866 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46867 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46868 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46869 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46870 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46871 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46872 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46873 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46874 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46875 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46876 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46877 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46878 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46879 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46880 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
46881 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
46882 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
46883 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46884 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46885 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
46886 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
46887 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46888 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46889 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
46890 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
46891 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46892 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46893 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46894 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46895 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
46896 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46897 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46898 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46899 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46900 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46901 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46902 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
46903 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
46904 { (char *)"delete_EventLoopActivator", (PyCFunction) _wrap_delete_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
46905 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
46906 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46907 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46908 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46909 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46910 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46911 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
46912 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46913 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46914 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46915 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46916 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46917 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46918 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46919 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46920 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46921 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46922 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46923 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46924 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46925 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46926 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46927 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46928 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46929 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46930 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46931 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46932 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46933 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46934 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46935 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46936 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46937 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46938 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46939 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46940 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46941 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46942 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46943 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46944 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46945 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46946 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46947 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46948 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46949 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46950 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46951 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46952 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46953 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46954 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46955 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46956 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46957 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46958 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46959 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46960 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46961 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46962 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46963 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46964 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46965 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46966 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46967 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46968 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46969 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46970 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46971 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46972 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46973 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46974 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46975 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46976 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46977 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46978 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46979 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46980 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46981 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46982 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46983 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46984 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46985 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46986 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46987 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46988 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46989 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46990 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46991 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46992 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46993 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46994 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46995 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46996 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46997 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46998 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46999 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47000 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47001 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47002 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47003 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
47004 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47005 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47006 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
47007 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47008 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47009 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47010 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
47011 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47012 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47013 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
47014 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47015 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47016 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47017 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
47018 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
47019 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
47020 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47021 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47022 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
47023 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
47024 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
47025 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
47026 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
47027 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
47028 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
47029 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47030 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47031 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47032 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47033 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47034 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47035 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47036 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
47037 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47038 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47039 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47040 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47041 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47042 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
47043 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
47044 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
47045 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
47046 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
47047 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
47048 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47049 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47050 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
47051 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
47052 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
47053 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
47054 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
47055 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
47056 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
47057 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
47058 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
47059 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
47060 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
47061 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
47062 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
47063 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47064 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
47065 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47066 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
47067 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47068 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47069 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47070 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47071 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47072 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47073 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47074 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47075 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47076 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
47077 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47078 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47079 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
47080 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
47081 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
47082 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47083 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
47084 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47085 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
47086 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
47087 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47088 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47089 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
47090 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
47091 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
47092 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
47093 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
47094 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
47095 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
47096 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
47097 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
47098 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
47099 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
47100 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47101 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47102 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47103 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47104 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
47105 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
47106 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
47107 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
47108 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
47109 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
47110 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47111 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
47112 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
47113 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
47114 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
47115 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
47116 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
47117 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
47118 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
47119 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
47120 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
47121 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
47122 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
47123 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
47124 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
47125 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
47126 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47127 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47128 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
47129 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
47130 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47131 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47132 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
47133 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47134 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47135 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47136 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47137 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
47138 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
47139 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
47140 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
47141 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47142 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
47143 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47144 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
47145 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
47146 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
47147 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47148 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47149 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47150 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47151 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
47152 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
47153 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
47154 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47155 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47156 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
47157 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
47158 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47159 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47160 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47161 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47162 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47163 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
47164 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
47165 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47166 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47167 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47168 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47169 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47170 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47171 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47172 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47173 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47174 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47175 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47176 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47177 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47178 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
47179 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47180 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
47181 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
47182 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
47183 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
47184 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
47185 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
47186 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
47187 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
47188 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47189 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47190 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47191 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47192 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47193 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47194 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47195 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47196 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47197 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
47198 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
47199 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47200 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47201 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47202 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47203 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47204 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
47205 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
47206 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47207 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47208 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47209 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47210 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47211 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
47212 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
47213 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47214 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47215 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
47216 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47217 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
47218 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47219 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
47220 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
47221 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
47222 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
47223 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47224 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
47225 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47226 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47227 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47228 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47229 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47230 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47231 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47232 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47233 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47234 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
47235 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47236 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47237 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47238 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47239 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_GetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47240 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
47241 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47242 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47243 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47244 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
47245 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
47246 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47247 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
47248 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47249 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
47250 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
47251 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47252 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47253 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47254 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47255 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47256 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47257 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47258 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47259 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47260 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47261 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47262 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
47263 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47264 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47265 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47266 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47267 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47268 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47269 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47270 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47271 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47272 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47273 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47274 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47275 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
47276 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47277 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47278 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47279 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47280 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47281 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47282 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47283 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47284 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
47285 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
47286 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
47287 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
47288 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
47289 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47290 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47291 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47292 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
47293 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47294 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
47295 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47296 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47297 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47298 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47299 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47300 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
47301 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
47302 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
47303 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
47304 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
47305 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
47306 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47307 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47308 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47309 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47310 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
47311 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
47312 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
47313 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47314 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47315 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47316 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47317 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47318 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47319 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47320 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47321 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47322 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47323 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47324 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
47325 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
47326 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
47327 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47328 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47329 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47330 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47331 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47332 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47333 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47334 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47335 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47336 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47337 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47338 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47339 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47340 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47341 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47342 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47343 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47344 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47345 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47346 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47347 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47348 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47349 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47350 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
47351 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47352 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47353 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47354 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47355 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47356 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47357 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
47358 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47359 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47360 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47361 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47362 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47363 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47364 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47365 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47366 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47367 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
47368 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47369 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47370 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
47371 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
47372 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47373 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47374 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47375 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47376 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47377 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47378 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47379 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
47380 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
47381 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
47382 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47383 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
47384 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47385 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47386 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47387 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
47388 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47389 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
47390 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
47391 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47392 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47393 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47394 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47395 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47396 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47397 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47398 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47399 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47400 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
47401 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47402 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47403 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47404 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47405 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47406 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47407 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47408 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47409 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47410 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
47411 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
47412 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
47413 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47414 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
47415 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
47416 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47417 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47418 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47419 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47420 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
47421 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47422 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47423 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
47424 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
47425 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47426 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47427 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47428 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47429 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47430 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47431 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47432 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47433 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47434 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
47435 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47436 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47437 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47438 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47439 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47440 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47441 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47442 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47443 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47444 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
47445 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47446 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47447 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47448 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47449 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47450 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47451 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47452 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47453 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
47454 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
47455 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
47456 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47457 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47458 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
47459 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47460 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47461 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47462 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47463 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47464 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47465 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
47466 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
47467 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
47468 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
47469 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
47470 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47471 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47472 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
47473 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
47474 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
47475 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47476 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
47477 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
47478 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
47479 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
47480 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
47481 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
47482 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
47483 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
47484 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
47485 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47486 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47487 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47488 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47489 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47490 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47491 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47492 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
47493 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47494 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47495 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47496 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47497 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47498 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
47499 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
47500 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47501 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
47502 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
47503 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
47504 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
47505 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
47506 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
47507 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
47508 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
47509 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
47510 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47511 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47512 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
47513 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
47514 { NULL, NULL, 0, NULL }
47515 };
47516
47517
47518 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
47519
47520 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
47521 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
47522 }
47523 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
47524 return (void *)((wxSizer *) ((wxBoxSizer *) x));
47525 }
47526 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
47527 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
47528 }
47529 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
47530 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47531 }
47532 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
47533 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47534 }
47535 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
47536 return (void *)((wxSizer *) ((wxGridSizer *) x));
47537 }
47538 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
47539 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
47540 }
47541 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
47542 return (void *)((wxSizer *) ((wxPySizer *) x));
47543 }
47544 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
47545 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
47546 }
47547 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
47548 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47549 }
47550 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
47551 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
47552 }
47553 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
47554 return (void *)((wxEvent *) ((wxMenuEvent *) x));
47555 }
47556 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
47557 return (void *)((wxEvent *) ((wxCloseEvent *) x));
47558 }
47559 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
47560 return (void *)((wxEvent *) ((wxMouseEvent *) x));
47561 }
47562 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
47563 return (void *)((wxEvent *) ((wxEraseEvent *) x));
47564 }
47565 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
47566 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
47567 }
47568 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
47569 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
47570 }
47571 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
47572 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
47573 }
47574 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
47575 return (void *)((wxEvent *) ((wxPyEvent *) x));
47576 }
47577 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
47578 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
47579 }
47580 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
47581 return (void *)((wxEvent *) ((wxIdleEvent *) x));
47582 }
47583 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
47584 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
47585 }
47586 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
47587 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
47588 }
47589 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
47590 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
47591 }
47592 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
47593 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
47594 }
47595 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
47596 return (void *)((wxEvent *) ((wxActivateEvent *) x));
47597 }
47598 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
47599 return (void *)((wxEvent *) ((wxSizeEvent *) x));
47600 }
47601 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
47602 return (void *)((wxEvent *) ((wxMoveEvent *) x));
47603 }
47604 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
47605 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
47606 }
47607 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
47608 return (void *)((wxEvent *) ((wxPaintEvent *) x));
47609 }
47610 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
47611 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
47612 }
47613 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
47614 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
47615 }
47616 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
47617 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
47618 }
47619 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
47620 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
47621 }
47622 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
47623 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47624 }
47625 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
47626 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
47627 }
47628 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
47629 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
47630 }
47631 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
47632 return (void *)((wxEvent *) ((wxFocusEvent *) x));
47633 }
47634 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
47635 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
47636 }
47637 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
47638 return (void *)((wxEvent *) ((wxShowEvent *) x));
47639 }
47640 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
47641 return (void *)((wxEvent *) ((wxCommandEvent *) x));
47642 }
47643 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
47644 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
47645 }
47646 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
47647 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47648 }
47649 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
47650 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
47651 }
47652 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
47653 return (void *)((wxEvent *) ((wxKeyEvent *) x));
47654 }
47655 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
47656 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
47657 }
47658 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
47659 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
47660 }
47661 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
47662 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
47663 }
47664 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
47665 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
47666 }
47667 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
47668 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
47669 }
47670 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
47671 return (void *)((wxControl *) ((wxControlWithItems *) x));
47672 }
47673 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
47674 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
47675 }
47676 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
47677 return (void *)((wxEvtHandler *) ((wxWindow *) x));
47678 }
47679 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
47680 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47681 }
47682 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
47683 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
47684 }
47685 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
47686 return (void *)((wxEvtHandler *) ((wxValidator *) x));
47687 }
47688 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
47689 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
47690 }
47691 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
47692 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
47693 }
47694 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
47695 return (void *)((wxEvtHandler *) ((wxMenu *) x));
47696 }
47697 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
47698 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
47699 }
47700 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
47701 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
47702 }
47703 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
47704 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
47705 }
47706 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
47707 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
47708 }
47709 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
47710 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
47711 }
47712 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
47713 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47714 }
47715 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
47716 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
47717 }
47718 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
47719 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
47720 }
47721 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
47722 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
47723 }
47724 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
47725 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47726 }
47727 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
47728 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47729 }
47730 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
47731 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
47732 }
47733 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
47734 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
47735 }
47736 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
47737 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
47738 }
47739 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
47740 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
47741 }
47742 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
47743 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
47744 }
47745 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
47746 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
47747 }
47748 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
47749 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
47750 }
47751 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
47752 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
47753 }
47754 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
47755 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
47756 }
47757 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
47758 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
47759 }
47760 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
47761 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
47762 }
47763 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
47764 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
47765 }
47766 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
47767 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
47768 }
47769 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
47770 return (void *)((wxObject *) ((wxSizerItem *) x));
47771 }
47772 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
47773 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
47774 }
47775 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
47776 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
47777 }
47778 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
47779 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
47780 }
47781 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
47782 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
47783 }
47784 static void *_p_wxSizerTo_p_wxObject(void *x) {
47785 return (void *)((wxObject *) ((wxSizer *) x));
47786 }
47787 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
47788 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47789 }
47790 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
47791 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
47792 }
47793 static void *_p_wxEventTo_p_wxObject(void *x) {
47794 return (void *)((wxObject *) ((wxEvent *) x));
47795 }
47796 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
47797 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
47798 }
47799 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
47800 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
47801 }
47802 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
47803 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
47804 }
47805 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
47806 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
47807 }
47808 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
47809 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
47810 }
47811 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
47812 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
47813 }
47814 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
47815 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
47816 }
47817 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
47818 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47819 }
47820 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
47821 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
47822 }
47823 static void *_p_wxControlTo_p_wxObject(void *x) {
47824 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
47825 }
47826 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
47827 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
47828 }
47829 static void *_p_wxFSFileTo_p_wxObject(void *x) {
47830 return (void *)((wxObject *) ((wxFSFile *) x));
47831 }
47832 static void *_p_wxPySizerTo_p_wxObject(void *x) {
47833 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
47834 }
47835 static void *_p_wxPyEventTo_p_wxObject(void *x) {
47836 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
47837 }
47838 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
47839 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
47840 }
47841 static void *_p_wxShowEventTo_p_wxObject(void *x) {
47842 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
47843 }
47844 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
47845 return (void *)((wxObject *) ((wxMenuItem *) x));
47846 }
47847 static void *_p_wxDateEventTo_p_wxObject(void *x) {
47848 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
47849 }
47850 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
47851 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
47852 }
47853 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
47854 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
47855 }
47856 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
47857 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
47858 }
47859 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
47860 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
47861 }
47862 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
47863 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
47864 }
47865 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
47866 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
47867 }
47868 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
47869 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
47870 }
47871 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
47872 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
47873 }
47874 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
47875 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
47876 }
47877 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
47878 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
47879 }
47880 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
47881 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
47882 }
47883 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
47884 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
47885 }
47886 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
47887 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
47888 }
47889 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
47890 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47891 }
47892 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
47893 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47894 }
47895 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
47896 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
47897 }
47898 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
47899 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
47900 }
47901 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
47902 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
47903 }
47904 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
47905 return (void *)((wxObject *) ((wxImageHandler *) x));
47906 }
47907 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
47908 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
47909 }
47910 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
47911 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
47912 }
47913 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
47914 return (void *)((wxObject *) ((wxEvtHandler *) x));
47915 }
47916 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
47917 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47918 }
47919 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
47920 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
47921 }
47922 static void *_p_wxImageTo_p_wxObject(void *x) {
47923 return (void *)((wxObject *) ((wxImage *) x));
47924 }
47925 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47926 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47927 }
47928 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47929 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47930 }
47931 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47932 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47933 }
47934 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47935 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47936 }
47937 static void *_p_wxWindowTo_p_wxObject(void *x) {
47938 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47939 }
47940 static void *_p_wxMenuTo_p_wxObject(void *x) {
47941 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47942 }
47943 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47944 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47945 }
47946 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47947 return (void *)((wxObject *) ((wxFileSystem *) x));
47948 }
47949 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47950 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47951 }
47952 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47953 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47954 }
47955 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47956 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47957 }
47958 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47959 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47960 }
47961 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47962 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47963 }
47964 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47965 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47966 }
47967 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47968 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47969 }
47970 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47971 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47972 }
47973 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47974 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47975 }
47976 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47977 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47978 }
47979 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47980 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47981 }
47982 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47983 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47984 }
47985 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47986 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47987 }
47988 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47989 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47990 }
47991 static void *_p_wxControlTo_p_wxWindow(void *x) {
47992 return (void *)((wxWindow *) ((wxControl *) x));
47993 }
47994 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47995 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47996 }
47997 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47998 return (void *)((wxWindow *) ((wxMenuBar *) x));
47999 }
48000 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
48001 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
48002 }
48003 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
48004 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
48005 }
48006 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
48007 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
48008 }
48009 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
48010 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
48011 }
48012 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
48013 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
48014 }
48015 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
48016 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
48017 }
48018 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
48019 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
48020 }
48021 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
48022 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
48023 }
48024 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
48025 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
48026 }
48027 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
48028 return (void *)((wxValidator *) ((wxPyValidator *) x));
48029 }
48030 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, 0};
48031 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, 0};
48032 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, 0};
48033 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, 0};
48034 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, 0};
48035 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, 0};
48036 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, 0};
48037 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, 0};
48038 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, 0};
48039 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, 0};
48040 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, 0};
48041 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, 0};
48042 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, 0};
48043 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, 0};
48044 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, 0};
48045 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, 0};
48046 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, 0};
48047 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, 0};
48048 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, 0};
48049 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, 0};
48050 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, 0};
48051 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, 0};
48052 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, 0};
48053 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, 0};
48054 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, 0};
48055 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, 0};
48056 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, 0};
48057 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, 0};
48058 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, 0};
48059 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, 0};
48060 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, 0};
48061 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, 0};
48062 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, 0};
48063 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0};
48064 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, 0};
48065 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, 0};
48066 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, 0};
48067 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, 0};
48068 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, 0};
48069 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, 0};
48070 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, 0};
48071 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, 0};
48072 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, 0};
48073 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, 0};
48074 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, 0};
48075 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, 0};
48076 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, 0};
48077 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, 0};
48078 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, 0};
48079 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, 0};
48080 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, 0};
48081 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, 0};
48082 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, 0};
48083 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, 0};
48084 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, 0};
48085 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, 0};
48086 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, 0};
48087 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, 0};
48088 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, 0};
48089 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, 0};
48090 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, 0};
48091 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, 0};
48092 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, 0};
48093 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, 0};
48094 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, 0};
48095 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, 0};
48096 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, 0};
48097 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, 0};
48098 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, 0};
48099 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, 0};
48100 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, 0};
48101 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, 0};
48102 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, 0};
48103 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, 0};
48104 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, 0};
48105 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, 0};
48106 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, 0};
48107 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, 0};
48108 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, 0};
48109 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, 0};
48110 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, 0};
48111 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, 0};
48112 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, 0};
48113 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, 0};
48114 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, 0};
48115 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, 0};
48116 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, 0};
48117 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, 0};
48118 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, 0};
48119 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, 0};
48120 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, 0};
48121 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, 0};
48122 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, 0};
48123 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, 0};
48124 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, 0};
48125 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, 0};
48126 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, 0};
48127 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, 0};
48128 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, 0};
48129 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, 0};
48130 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, 0};
48131 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, 0};
48132 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, 0};
48133 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, 0};
48134 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, 0};
48135 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, 0};
48136 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, 0};
48137 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, 0};
48138 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, 0};
48139 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, 0};
48140 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, 0};
48141 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, 0};
48142 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, 0};
48143 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, 0};
48144 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, 0};
48145 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, 0};
48146 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, 0};
48147 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, 0};
48148 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, 0};
48149 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, 0};
48150 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, 0};
48151 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, 0};
48152 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, 0};
48153 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, 0};
48154 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, 0};
48155 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, 0};
48156 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, 0};
48157 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, 0};
48158 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, 0};
48159 static swig_type_info _swigt__ptrdiff_t = {"_ptrdiff_t", "ptrdiff_t", 0, 0, 0};
48160 static swig_type_info _swigt__std__ptrdiff_t = {"_std__ptrdiff_t", "std::ptrdiff_t", 0, 0, 0};
48161 static swig_type_info _swigt__unsigned_int = {"_unsigned_int", "unsigned int|std::size_t", 0, 0, 0};
48162
48163 static swig_type_info *swig_type_initial[] = {
48164 &_swigt__p_buffer,
48165 &_swigt__p_char,
48166 &_swigt__p_form_ops_t,
48167 &_swigt__p_int,
48168 &_swigt__p_long,
48169 &_swigt__p_unsigned_char,
48170 &_swigt__p_unsigned_int,
48171 &_swigt__p_unsigned_long,
48172 &_swigt__p_wxANIHandler,
48173 &_swigt__p_wxAcceleratorEntry,
48174 &_swigt__p_wxAcceleratorTable,
48175 &_swigt__p_wxActivateEvent,
48176 &_swigt__p_wxAppTraits,
48177 &_swigt__p_wxArrayString,
48178 &_swigt__p_wxBMPHandler,
48179 &_swigt__p_wxBitmap,
48180 &_swigt__p_wxBoxSizer,
48181 &_swigt__p_wxButton,
48182 &_swigt__p_wxCURHandler,
48183 &_swigt__p_wxCaret,
48184 &_swigt__p_wxChildFocusEvent,
48185 &_swigt__p_wxCloseEvent,
48186 &_swigt__p_wxColour,
48187 &_swigt__p_wxCommandEvent,
48188 &_swigt__p_wxContextMenuEvent,
48189 &_swigt__p_wxControl,
48190 &_swigt__p_wxControlWithItems,
48191 &_swigt__p_wxCursor,
48192 &_swigt__p_wxDC,
48193 &_swigt__p_wxDateEvent,
48194 &_swigt__p_wxDateTime,
48195 &_swigt__p_wxDisplayChangedEvent,
48196 &_swigt__p_wxDropFilesEvent,
48197 &_swigt__p_wxDuplexMode,
48198 &_swigt__p_wxEraseEvent,
48199 &_swigt__p_wxEvent,
48200 &_swigt__p_wxEventLoop,
48201 &_swigt__p_wxEventLoopActivator,
48202 &_swigt__p_wxEvtHandler,
48203 &_swigt__p_wxFSFile,
48204 &_swigt__p_wxFileSystem,
48205 &_swigt__p_wxFileSystemHandler,
48206 &_swigt__p_wxFlexGridSizer,
48207 &_swigt__p_wxFocusEvent,
48208 &_swigt__p_wxFont,
48209 &_swigt__p_wxFrame,
48210 &_swigt__p_wxGBPosition,
48211 &_swigt__p_wxGBSizerItem,
48212 &_swigt__p_wxGBSpan,
48213 &_swigt__p_wxGIFHandler,
48214 &_swigt__p_wxGridBagSizer,
48215 &_swigt__p_wxGridSizer,
48216 &_swigt__p_wxICOHandler,
48217 &_swigt__p_wxIconizeEvent,
48218 &_swigt__p_wxIdleEvent,
48219 &_swigt__p_wxImage,
48220 &_swigt__p_wxImageHandler,
48221 &_swigt__p_wxImageHistogram,
48222 &_swigt__p_wxImage_HSVValue,
48223 &_swigt__p_wxImage_RGBValue,
48224 &_swigt__p_wxIndividualLayoutConstraint,
48225 &_swigt__p_wxInitDialogEvent,
48226 &_swigt__p_wxInputStream,
48227 &_swigt__p_wxInternetFSHandler,
48228 &_swigt__p_wxItemContainer,
48229 &_swigt__p_wxJPEGHandler,
48230 &_swigt__p_wxKeyEvent,
48231 &_swigt__p_wxLayoutConstraints,
48232 &_swigt__p_wxMaximizeEvent,
48233 &_swigt__p_wxMemoryFSHandler,
48234 &_swigt__p_wxMenu,
48235 &_swigt__p_wxMenuBar,
48236 &_swigt__p_wxMenuBarBase,
48237 &_swigt__p_wxMenuEvent,
48238 &_swigt__p_wxMenuItem,
48239 &_swigt__p_wxMouseCaptureChangedEvent,
48240 &_swigt__p_wxMouseEvent,
48241 &_swigt__p_wxMoveEvent,
48242 &_swigt__p_wxNavigationKeyEvent,
48243 &_swigt__p_wxNcPaintEvent,
48244 &_swigt__p_wxNotifyEvent,
48245 &_swigt__p_wxObject,
48246 &_swigt__p_wxOutputStream,
48247 &_swigt__p_wxPCXHandler,
48248 &_swigt__p_wxPNGHandler,
48249 &_swigt__p_wxPNMHandler,
48250 &_swigt__p_wxPaintEvent,
48251 &_swigt__p_wxPaletteChangedEvent,
48252 &_swigt__p_wxPaperSize,
48253 &_swigt__p_wxPoint,
48254 &_swigt__p_wxPoint2D,
48255 &_swigt__p_wxPropagateOnce,
48256 &_swigt__p_wxPropagationDisabler,
48257 &_swigt__p_wxPyApp,
48258 &_swigt__p_wxPyCommandEvent,
48259 &_swigt__p_wxPyDropTarget,
48260 &_swigt__p_wxPyEvent,
48261 &_swigt__p_wxPyFileSystemHandler,
48262 &_swigt__p_wxPyImageHandler,
48263 &_swigt__p_wxPyInputStream,
48264 &_swigt__p_wxPySizer,
48265 &_swigt__p_wxPyValidator,
48266 &_swigt__p_wxQuantize,
48267 &_swigt__p_wxQueryNewPaletteEvent,
48268 &_swigt__p_wxRealPoint,
48269 &_swigt__p_wxRect,
48270 &_swigt__p_wxRegion,
48271 &_swigt__p_wxScrollEvent,
48272 &_swigt__p_wxScrollWinEvent,
48273 &_swigt__p_wxSetCursorEvent,
48274 &_swigt__p_wxShowEvent,
48275 &_swigt__p_wxSize,
48276 &_swigt__p_wxSizeEvent,
48277 &_swigt__p_wxSizer,
48278 &_swigt__p_wxSizerItem,
48279 &_swigt__p_wxStaticBox,
48280 &_swigt__p_wxStaticBoxSizer,
48281 &_swigt__p_wxStdDialogButtonSizer,
48282 &_swigt__p_wxSysColourChangedEvent,
48283 &_swigt__p_wxTIFFHandler,
48284 &_swigt__p_wxToolTip,
48285 &_swigt__p_wxUpdateUIEvent,
48286 &_swigt__p_wxValidator,
48287 &_swigt__p_wxVisualAttributes,
48288 &_swigt__p_wxWindow,
48289 &_swigt__p_wxWindowCreateEvent,
48290 &_swigt__p_wxWindowDestroyEvent,
48291 &_swigt__p_wxXPMHandler,
48292 &_swigt__p_wxZipFSHandler,
48293 &_swigt__ptrdiff_t,
48294 &_swigt__std__ptrdiff_t,
48295 &_swigt__unsigned_int,
48296 };
48297
48298 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
48299 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
48300 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
48301 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
48302 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
48303 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
48304 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
48305 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
48306 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
48307 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
48308 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
48309 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
48310 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
48311 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
48312 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}};
48313 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
48314 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}};
48315 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
48316 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}};
48317 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
48318 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
48319 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
48320 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
48321 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}};
48322 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
48323 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}};
48324 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
48325 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
48326 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
48327 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
48328 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
48329 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48330 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
48331 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
48332 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
48333 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}};
48334 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
48335 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
48336 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}};
48337 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
48338 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
48339 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}};
48340 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}};
48341 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
48342 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
48343 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
48344 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
48345 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
48346 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
48347 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
48348 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
48349 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}};
48350 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}};
48351 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48352 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
48353 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
48354 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}};
48355 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
48356 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
48357 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
48358 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
48359 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
48360 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
48361 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48362 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}};
48363 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
48364 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
48365 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
48366 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48367 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48368 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
48369 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
48370 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
48371 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
48372 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
48373 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48374 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
48375 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
48376 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
48377 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
48378 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
48379 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}};
48380 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
48381 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
48382 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
48383 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
48384 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
48385 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48386 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
48387 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
48388 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
48389 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
48390 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
48391 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
48392 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
48393 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
48394 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
48395 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
48396 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
48397 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
48398 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
48399 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
48400 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
48401 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
48402 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
48403 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
48404 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
48405 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
48406 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
48407 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
48408 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
48409 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
48410 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48411 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}};
48412 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}};
48413 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
48414 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
48415 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
48416 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48417 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
48418 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
48419 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
48420 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}};
48421 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
48422 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}};
48423 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
48424 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
48425 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
48426 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48427 static swig_cast_info _swigc__ptrdiff_t[] = { {&_swigt__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
48428 static swig_cast_info _swigc__std__ptrdiff_t[] = { {&_swigt__std__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
48429 static swig_cast_info _swigc__unsigned_int[] = { {&_swigt__unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
48430
48431 static swig_cast_info *swig_cast_initial[] = {
48432 _swigc__p_buffer,
48433 _swigc__p_char,
48434 _swigc__p_form_ops_t,
48435 _swigc__p_int,
48436 _swigc__p_long,
48437 _swigc__p_unsigned_char,
48438 _swigc__p_unsigned_int,
48439 _swigc__p_unsigned_long,
48440 _swigc__p_wxANIHandler,
48441 _swigc__p_wxAcceleratorEntry,
48442 _swigc__p_wxAcceleratorTable,
48443 _swigc__p_wxActivateEvent,
48444 _swigc__p_wxAppTraits,
48445 _swigc__p_wxArrayString,
48446 _swigc__p_wxBMPHandler,
48447 _swigc__p_wxBitmap,
48448 _swigc__p_wxBoxSizer,
48449 _swigc__p_wxButton,
48450 _swigc__p_wxCURHandler,
48451 _swigc__p_wxCaret,
48452 _swigc__p_wxChildFocusEvent,
48453 _swigc__p_wxCloseEvent,
48454 _swigc__p_wxColour,
48455 _swigc__p_wxCommandEvent,
48456 _swigc__p_wxContextMenuEvent,
48457 _swigc__p_wxControl,
48458 _swigc__p_wxControlWithItems,
48459 _swigc__p_wxCursor,
48460 _swigc__p_wxDC,
48461 _swigc__p_wxDateEvent,
48462 _swigc__p_wxDateTime,
48463 _swigc__p_wxDisplayChangedEvent,
48464 _swigc__p_wxDropFilesEvent,
48465 _swigc__p_wxDuplexMode,
48466 _swigc__p_wxEraseEvent,
48467 _swigc__p_wxEvent,
48468 _swigc__p_wxEventLoop,
48469 _swigc__p_wxEventLoopActivator,
48470 _swigc__p_wxEvtHandler,
48471 _swigc__p_wxFSFile,
48472 _swigc__p_wxFileSystem,
48473 _swigc__p_wxFileSystemHandler,
48474 _swigc__p_wxFlexGridSizer,
48475 _swigc__p_wxFocusEvent,
48476 _swigc__p_wxFont,
48477 _swigc__p_wxFrame,
48478 _swigc__p_wxGBPosition,
48479 _swigc__p_wxGBSizerItem,
48480 _swigc__p_wxGBSpan,
48481 _swigc__p_wxGIFHandler,
48482 _swigc__p_wxGridBagSizer,
48483 _swigc__p_wxGridSizer,
48484 _swigc__p_wxICOHandler,
48485 _swigc__p_wxIconizeEvent,
48486 _swigc__p_wxIdleEvent,
48487 _swigc__p_wxImage,
48488 _swigc__p_wxImageHandler,
48489 _swigc__p_wxImageHistogram,
48490 _swigc__p_wxImage_HSVValue,
48491 _swigc__p_wxImage_RGBValue,
48492 _swigc__p_wxIndividualLayoutConstraint,
48493 _swigc__p_wxInitDialogEvent,
48494 _swigc__p_wxInputStream,
48495 _swigc__p_wxInternetFSHandler,
48496 _swigc__p_wxItemContainer,
48497 _swigc__p_wxJPEGHandler,
48498 _swigc__p_wxKeyEvent,
48499 _swigc__p_wxLayoutConstraints,
48500 _swigc__p_wxMaximizeEvent,
48501 _swigc__p_wxMemoryFSHandler,
48502 _swigc__p_wxMenu,
48503 _swigc__p_wxMenuBar,
48504 _swigc__p_wxMenuBarBase,
48505 _swigc__p_wxMenuEvent,
48506 _swigc__p_wxMenuItem,
48507 _swigc__p_wxMouseCaptureChangedEvent,
48508 _swigc__p_wxMouseEvent,
48509 _swigc__p_wxMoveEvent,
48510 _swigc__p_wxNavigationKeyEvent,
48511 _swigc__p_wxNcPaintEvent,
48512 _swigc__p_wxNotifyEvent,
48513 _swigc__p_wxObject,
48514 _swigc__p_wxOutputStream,
48515 _swigc__p_wxPCXHandler,
48516 _swigc__p_wxPNGHandler,
48517 _swigc__p_wxPNMHandler,
48518 _swigc__p_wxPaintEvent,
48519 _swigc__p_wxPaletteChangedEvent,
48520 _swigc__p_wxPaperSize,
48521 _swigc__p_wxPoint,
48522 _swigc__p_wxPoint2D,
48523 _swigc__p_wxPropagateOnce,
48524 _swigc__p_wxPropagationDisabler,
48525 _swigc__p_wxPyApp,
48526 _swigc__p_wxPyCommandEvent,
48527 _swigc__p_wxPyDropTarget,
48528 _swigc__p_wxPyEvent,
48529 _swigc__p_wxPyFileSystemHandler,
48530 _swigc__p_wxPyImageHandler,
48531 _swigc__p_wxPyInputStream,
48532 _swigc__p_wxPySizer,
48533 _swigc__p_wxPyValidator,
48534 _swigc__p_wxQuantize,
48535 _swigc__p_wxQueryNewPaletteEvent,
48536 _swigc__p_wxRealPoint,
48537 _swigc__p_wxRect,
48538 _swigc__p_wxRegion,
48539 _swigc__p_wxScrollEvent,
48540 _swigc__p_wxScrollWinEvent,
48541 _swigc__p_wxSetCursorEvent,
48542 _swigc__p_wxShowEvent,
48543 _swigc__p_wxSize,
48544 _swigc__p_wxSizeEvent,
48545 _swigc__p_wxSizer,
48546 _swigc__p_wxSizerItem,
48547 _swigc__p_wxStaticBox,
48548 _swigc__p_wxStaticBoxSizer,
48549 _swigc__p_wxStdDialogButtonSizer,
48550 _swigc__p_wxSysColourChangedEvent,
48551 _swigc__p_wxTIFFHandler,
48552 _swigc__p_wxToolTip,
48553 _swigc__p_wxUpdateUIEvent,
48554 _swigc__p_wxValidator,
48555 _swigc__p_wxVisualAttributes,
48556 _swigc__p_wxWindow,
48557 _swigc__p_wxWindowCreateEvent,
48558 _swigc__p_wxWindowDestroyEvent,
48559 _swigc__p_wxXPMHandler,
48560 _swigc__p_wxZipFSHandler,
48561 _swigc__ptrdiff_t,
48562 _swigc__std__ptrdiff_t,
48563 _swigc__unsigned_int,
48564 };
48565
48566
48567 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
48568
48569 static swig_const_info swig_const_table[] = {
48570 {0, 0, 0, 0.0, 0, 0}};
48571
48572 #ifdef __cplusplus
48573 }
48574 #endif
48575 /*************************************************************************
48576 * Type initialization:
48577 * This problem is tough by the requirement that no dynamic
48578 * memory is used. Also, since swig_type_info structures store pointers to
48579 * swig_cast_info structures and swig_cast_info structures store pointers back
48580 * to swig_type_info structures, we need some lookup code at initialization.
48581 * The idea is that swig generates all the structures that are needed.
48582 * The runtime then collects these partially filled structures.
48583 * The SWIG_InitializeModule function takes these initial arrays out of
48584 * swig_module, and does all the lookup, filling in the swig_module.types
48585 * array with the correct data and linking the correct swig_cast_info
48586 * structures together.
48587
48588 * The generated swig_type_info structures are assigned staticly to an initial
48589 * array. We just loop though that array, and handle each type individually.
48590 * First we lookup if this type has been already loaded, and if so, use the
48591 * loaded structure instead of the generated one. Then we have to fill in the
48592 * cast linked list. The cast data is initially stored in something like a
48593 * two-dimensional array. Each row corresponds to a type (there are the same
48594 * number of rows as there are in the swig_type_initial array). Each entry in
48595 * a column is one of the swig_cast_info structures for that type.
48596 * The cast_initial array is actually an array of arrays, because each row has
48597 * a variable number of columns. So to actually build the cast linked list,
48598 * we find the array of casts associated with the type, and loop through it
48599 * adding the casts to the list. The one last trick we need to do is making
48600 * sure the type pointer in the swig_cast_info struct is correct.
48601
48602 * First off, we lookup the cast->type name to see if it is already loaded.
48603 * There are three cases to handle:
48604 * 1) If the cast->type has already been loaded AND the type we are adding
48605 * casting info to has not been loaded (it is in this module), THEN we
48606 * replace the cast->type pointer with the type pointer that has already
48607 * been loaded.
48608 * 2) If BOTH types (the one we are adding casting info to, and the
48609 * cast->type) are loaded, THEN the cast info has already been loaded by
48610 * the previous module so we just ignore it.
48611 * 3) Finally, if cast->type has not already been loaded, then we add that
48612 * swig_cast_info to the linked list (because the cast->type) pointer will
48613 * be correct.
48614 **/
48615
48616 #ifdef __cplusplus
48617 extern "C" {
48618 #if 0
48619 } /* c-mode */
48620 #endif
48621 #endif
48622
48623 #if 0
48624 #define SWIGRUNTIME_DEBUG
48625 #endif
48626
48627 SWIGRUNTIME void
48628 SWIG_InitializeModule(void *clientdata) {
48629 size_t i;
48630 swig_module_info *module_head;
48631 static int init_run = 0;
48632
48633 clientdata = clientdata;
48634
48635 if (init_run) return;
48636 init_run = 1;
48637
48638 /* Initialize the swig_module */
48639 swig_module.type_initial = swig_type_initial;
48640 swig_module.cast_initial = swig_cast_initial;
48641
48642 /* Try and load any already created modules */
48643 module_head = SWIG_GetModule(clientdata);
48644 if (module_head) {
48645 swig_module.next = module_head->next;
48646 module_head->next = &swig_module;
48647 } else {
48648 /* This is the first module loaded */
48649 swig_module.next = &swig_module;
48650 SWIG_SetModule(clientdata, &swig_module);
48651 }
48652
48653 /* Now work on filling in swig_module.types */
48654 #ifdef SWIGRUNTIME_DEBUG
48655 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
48656 #endif
48657 for (i = 0; i < swig_module.size; ++i) {
48658 swig_type_info *type = 0;
48659 swig_type_info *ret;
48660 swig_cast_info *cast;
48661
48662 #ifdef SWIGRUNTIME_DEBUG
48663 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
48664 #endif
48665
48666 /* if there is another module already loaded */
48667 if (swig_module.next != &swig_module) {
48668 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
48669 }
48670 if (type) {
48671 /* Overwrite clientdata field */
48672 #ifdef SWIGRUNTIME_DEBUG
48673 printf("SWIG_InitializeModule: found type %s\n", type->name);
48674 #endif
48675 if (swig_module.type_initial[i]->clientdata) {
48676 type->clientdata = swig_module.type_initial[i]->clientdata;
48677 #ifdef SWIGRUNTIME_DEBUG
48678 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
48679 #endif
48680 }
48681 } else {
48682 type = swig_module.type_initial[i];
48683 }
48684
48685 /* Insert casting types */
48686 cast = swig_module.cast_initial[i];
48687 while (cast->type) {
48688 /* Don't need to add information already in the list */
48689 ret = 0;
48690 #ifdef SWIGRUNTIME_DEBUG
48691 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
48692 #endif
48693 if (swig_module.next != &swig_module) {
48694 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
48695 #ifdef SWIGRUNTIME_DEBUG
48696 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
48697 #endif
48698 }
48699 if (ret) {
48700 if (type == swig_module.type_initial[i]) {
48701 #ifdef SWIGRUNTIME_DEBUG
48702 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
48703 #endif
48704 cast->type = ret;
48705 ret = 0;
48706 } else {
48707 /* Check for casting already in the list */
48708 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
48709 #ifdef SWIGRUNTIME_DEBUG
48710 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
48711 #endif
48712 if (!ocast) ret = 0;
48713 }
48714 }
48715
48716 if (!ret) {
48717 #ifdef SWIGRUNTIME_DEBUG
48718 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
48719 #endif
48720 if (type->cast) {
48721 type->cast->prev = cast;
48722 cast->next = type->cast;
48723 }
48724 type->cast = cast;
48725 }
48726 cast++;
48727 }
48728 /* Set entry in modules->types array equal to the type */
48729 swig_module.types[i] = type;
48730 }
48731 swig_module.types[i] = 0;
48732
48733 #ifdef SWIGRUNTIME_DEBUG
48734 printf("**** SWIG_InitializeModule: Cast List ******\n");
48735 for (i = 0; i < swig_module.size; ++i) {
48736 int j = 0;
48737 swig_cast_info *cast = swig_module.cast_initial[i];
48738 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
48739 while (cast->type) {
48740 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
48741 cast++;
48742 ++j;
48743 }
48744 printf("---- Total casts: %d\n",j);
48745 }
48746 printf("**** SWIG_InitializeModule: Cast List ******\n");
48747 #endif
48748 }
48749
48750 /* This function will propagate the clientdata field of type to
48751 * any new swig_type_info structures that have been added into the list
48752 * of equivalent types. It is like calling
48753 * SWIG_TypeClientData(type, clientdata) a second time.
48754 */
48755 SWIGRUNTIME void
48756 SWIG_PropagateClientData(void) {
48757 size_t i;
48758 swig_cast_info *equiv;
48759 static int init_run = 0;
48760
48761 if (init_run) return;
48762 init_run = 1;
48763
48764 for (i = 0; i < swig_module.size; i++) {
48765 if (swig_module.types[i]->clientdata) {
48766 equiv = swig_module.types[i]->cast;
48767 while (equiv) {
48768 if (!equiv->converter) {
48769 if (equiv->type && !equiv->type->clientdata)
48770 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
48771 }
48772 equiv = equiv->next;
48773 }
48774 }
48775 }
48776 }
48777
48778 #ifdef __cplusplus
48779 #if 0
48780 {
48781 /* c-mode */
48782 #endif
48783 }
48784 #endif
48785
48786
48787
48788 #ifdef __cplusplus
48789 extern "C" {
48790 #endif
48791
48792 /* Python-specific SWIG API */
48793 #define SWIG_newvarlink() SWIG_Python_newvarlink()
48794 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
48795 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
48796
48797 /* -----------------------------------------------------------------------------
48798 * global variable support code.
48799 * ----------------------------------------------------------------------------- */
48800
48801 typedef struct swig_globalvar {
48802 char *name; /* Name of global variable */
48803 PyObject *(*get_attr)(void); /* Return the current value */
48804 int (*set_attr)(PyObject *); /* Set the value */
48805 struct swig_globalvar *next;
48806 } swig_globalvar;
48807
48808 typedef struct swig_varlinkobject {
48809 PyObject_HEAD
48810 swig_globalvar *vars;
48811 } swig_varlinkobject;
48812
48813 SWIGINTERN PyObject *
48814 swig_varlink_repr(swig_varlinkobject *v) {
48815 v = v;
48816 return PyString_FromString("<Swig global variables>");
48817 }
48818
48819 SWIGINTERN int
48820 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
48821 swig_globalvar *var;
48822 flags = flags;
48823 fprintf(fp,"Swig global variables { ");
48824 for (var = v->vars; var; var=var->next) {
48825 fprintf(fp,"%s", var->name);
48826 if (var->next) fprintf(fp,", ");
48827 }
48828 fprintf(fp," }\n");
48829 return 0;
48830 }
48831
48832 SWIGINTERN PyObject *
48833 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
48834 swig_globalvar *var = v->vars;
48835 while (var) {
48836 if (strcmp(var->name,n) == 0) {
48837 return (*var->get_attr)();
48838 }
48839 var = var->next;
48840 }
48841 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48842 return NULL;
48843 }
48844
48845 SWIGINTERN int
48846 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
48847 swig_globalvar *var = v->vars;
48848 while (var) {
48849 if (strcmp(var->name,n) == 0) {
48850 return (*var->set_attr)(p);
48851 }
48852 var = var->next;
48853 }
48854 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48855 return 1;
48856 }
48857
48858 SWIGINTERN PyTypeObject*
48859 swig_varlink_type(void) {
48860 static char varlink__doc__[] = "Swig var link object";
48861 static PyTypeObject varlink_type
48862 #if !defined(__cplusplus)
48863 ;
48864 static int type_init = 0;
48865 if (!type_init) {
48866 PyTypeObject tmp
48867 #endif
48868 = {
48869 PyObject_HEAD_INIT(&PyType_Type)
48870 0, /* Number of items in variable part (ob_size) */
48871 (char *)"swigvarlink", /* Type name (tp_name) */
48872 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
48873 0, /* Itemsize (tp_itemsize) */
48874 0, /* Deallocator (tp_dealloc) */
48875 (printfunc) swig_varlink_print, /* Print (tp_print) */
48876 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
48877 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
48878 0, /* tp_compare */
48879 (reprfunc) swig_varlink_repr, /* tp_repr */
48880 0, /* tp_as_number */
48881 0, /* tp_as_sequence */
48882 0, /* tp_as_mapping */
48883 0, /* tp_hash */
48884 0, /* tp_call */
48885 0, /* tp_str */
48886 0, /* tp_getattro */
48887 0, /* tp_setattro */
48888 0, /* tp_as_buffer */
48889 0, /* tp_flags */
48890 varlink__doc__, /* tp_doc */
48891 #if PY_VERSION_HEX >= 0x02000000
48892 0, /* tp_traverse */
48893 0, /* tp_clear */
48894 #endif
48895 #if PY_VERSION_HEX >= 0x02010000
48896 0, /* tp_richcompare */
48897 0, /* tp_weaklistoffset */
48898 #endif
48899 #if PY_VERSION_HEX >= 0x02020000
48900 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
48901 #endif
48902 #if PY_VERSION_HEX >= 0x02030000
48903 0, /* tp_del */
48904 #endif
48905 #ifdef COUNT_ALLOCS
48906 0,0,0,0 /* tp_alloc -> tp_next */
48907 #endif
48908 };
48909 #if !defined(__cplusplus)
48910 varlink_type = tmp;
48911 type_init = 1;
48912 }
48913 #endif
48914 return &varlink_type;
48915 }
48916
48917 /* Create a variable linking object for use later */
48918 SWIGINTERN PyObject *
48919 SWIG_Python_newvarlink(void) {
48920 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
48921 if (result) {
48922 result->vars = 0;
48923 }
48924 return ((PyObject*) result);
48925 }
48926
48927 SWIGINTERN void
48928 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
48929 swig_varlinkobject *v = (swig_varlinkobject *) p;
48930 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
48931 if (gv) {
48932 size_t size = strlen(name)+1;
48933 gv->name = (char *)malloc(size);
48934 if (gv->name) {
48935 strncpy(gv->name,name,size);
48936 gv->get_attr = get_attr;
48937 gv->set_attr = set_attr;
48938 gv->next = v->vars;
48939 }
48940 }
48941 v->vars = gv;
48942 }
48943
48944 /* -----------------------------------------------------------------------------
48945 * constants/methods manipulation
48946 * ----------------------------------------------------------------------------- */
48947
48948 /* Install Constants */
48949 SWIGINTERN void
48950 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
48951 PyObject *obj = 0;
48952 size_t i;
48953 for (i = 0; constants[i].type; ++i) {
48954 switch(constants[i].type) {
48955 case SWIG_PY_INT:
48956 obj = PyInt_FromLong(constants[i].lvalue);
48957 break;
48958 case SWIG_PY_FLOAT:
48959 obj = PyFloat_FromDouble(constants[i].dvalue);
48960 break;
48961 case SWIG_PY_STRING:
48962 if (constants[i].pvalue) {
48963 obj = PyString_FromString((char *) constants[i].pvalue);
48964 } else {
48965 Py_INCREF(Py_None);
48966 obj = Py_None;
48967 }
48968 break;
48969 case SWIG_PY_POINTER:
48970 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
48971 break;
48972 case SWIG_PY_BINARY:
48973 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
48974 break;
48975 default:
48976 obj = 0;
48977 break;
48978 }
48979 if (obj) {
48980 PyDict_SetItemString(d,constants[i].name,obj);
48981 Py_DECREF(obj);
48982 }
48983 }
48984 }
48985
48986 /* -----------------------------------------------------------------------------*/
48987 /* Fix SwigMethods to carry the callback ptrs when needed */
48988 /* -----------------------------------------------------------------------------*/
48989
48990 SWIGINTERN void
48991 SWIG_Python_FixMethods(PyMethodDef *methods,
48992 swig_const_info *const_table,
48993 swig_type_info **types,
48994 swig_type_info **types_initial) {
48995 size_t i;
48996 for (i = 0; methods[i].ml_name; ++i) {
48997 char *c = methods[i].ml_doc;
48998 if (c && (c = strstr(c, "swig_ptr: "))) {
48999 int j;
49000 swig_const_info *ci = 0;
49001 char *name = c + 10;
49002 for (j = 0; const_table[j].type; ++j) {
49003 if (strncmp(const_table[j].name, name,
49004 strlen(const_table[j].name)) == 0) {
49005 ci = &(const_table[j]);
49006 break;
49007 }
49008 }
49009 if (ci) {
49010 size_t shift = (ci->ptype) - types;
49011 swig_type_info *ty = types_initial[shift];
49012 size_t ldoc = (c - methods[i].ml_doc);
49013 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
49014 char *ndoc = (char*)malloc(ldoc + lptr + 10);
49015 if (ndoc) {
49016 char *buff = ndoc;
49017 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
49018 if (ptr) {
49019 strncpy(buff, methods[i].ml_doc, ldoc);
49020 buff += ldoc;
49021 strncpy(buff, "swig_ptr: ", 10);
49022 buff += 10;
49023 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
49024 methods[i].ml_doc = ndoc;
49025 }
49026 }
49027 }
49028 }
49029 }
49030 }
49031
49032 /* -----------------------------------------------------------------------------*
49033 * Initialize type list
49034 * -----------------------------------------------------------------------------*/
49035
49036 #ifdef __cplusplus
49037 }
49038 #endif
49039
49040 /* -----------------------------------------------------------------------------*
49041 * Partial Init method
49042 * -----------------------------------------------------------------------------*/
49043
49044 #ifdef __cplusplus
49045 extern "C"
49046 #endif
49047 SWIGEXPORT void SWIG_init(void) {
49048 static PyObject *SWIG_globals = 0;
49049 PyObject *m, *d;
49050 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
49051
49052 /* Fix SwigMethods to carry the callback ptrs when needed */
49053 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
49054
49055 m = Py_InitModule((char *) SWIG_name, SwigMethods);
49056 d = PyModule_GetDict(m);
49057
49058 SWIG_InitializeModule(0);
49059 SWIG_InstallConstants(d,swig_const_table);
49060
49061
49062 #ifndef wxPyUSE_EXPORT
49063 // Make our API structure a CObject so other modules can import it
49064 // from this module.
49065 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
49066 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
49067 Py_XDECREF(cobj);
49068 #endif
49069
49070 {
49071 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int(static_cast<int >(wxNOT_FOUND)));
49072 }
49073 {
49074 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int(static_cast<int >(wxVSCROLL)));
49075 }
49076 {
49077 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int(static_cast<int >(wxHSCROLL)));
49078 }
49079 {
49080 PyDict_SetItemString(d,"CAPTION", SWIG_From_int(static_cast<int >(wxCAPTION)));
49081 }
49082 {
49083 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int(static_cast<int >(wxDOUBLE_BORDER)));
49084 }
49085 {
49086 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int(static_cast<int >(wxSUNKEN_BORDER)));
49087 }
49088 {
49089 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int(static_cast<int >(wxRAISED_BORDER)));
49090 }
49091 {
49092 PyDict_SetItemString(d,"BORDER", SWIG_From_int(static_cast<int >(wxBORDER)));
49093 }
49094 {
49095 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int(static_cast<int >(wxSIMPLE_BORDER)));
49096 }
49097 {
49098 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int(static_cast<int >(wxSTATIC_BORDER)));
49099 }
49100 {
49101 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int(static_cast<int >(wxTRANSPARENT_WINDOW)));
49102 }
49103 {
49104 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int(static_cast<int >(wxNO_BORDER)));
49105 }
49106 {
49107 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int(static_cast<int >(wxDEFAULT_CONTROL_BORDER)));
49108 }
49109 {
49110 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int(static_cast<int >(wxDEFAULT_STATUSBAR_STYLE)));
49111 }
49112 {
49113 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int(static_cast<int >(wxTAB_TRAVERSAL)));
49114 }
49115 {
49116 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int(static_cast<int >(wxWANTS_CHARS)));
49117 }
49118 {
49119 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int(static_cast<int >(wxPOPUP_WINDOW)));
49120 }
49121 {
49122 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int(static_cast<int >(wxCENTER_FRAME)));
49123 }
49124 {
49125 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int(static_cast<int >(wxCENTRE_ON_SCREEN)));
49126 }
49127 {
49128 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int(static_cast<int >(wxCENTER_ON_SCREEN)));
49129 }
49130 {
49131 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int(static_cast<int >(wxCLIP_CHILDREN)));
49132 }
49133 {
49134 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int(static_cast<int >(wxCLIP_SIBLINGS)));
49135 }
49136 {
49137 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int(static_cast<int >(wxALWAYS_SHOW_SB)));
49138 }
49139 {
49140 PyDict_SetItemString(d,"RETAINED", SWIG_From_int(static_cast<int >(wxRETAINED)));
49141 }
49142 {
49143 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int(static_cast<int >(wxBACKINGSTORE)));
49144 }
49145 {
49146 PyDict_SetItemString(d,"COLOURED", SWIG_From_int(static_cast<int >(wxCOLOURED)));
49147 }
49148 {
49149 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int(static_cast<int >(wxFIXED_LENGTH)));
49150 }
49151 {
49152 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int(static_cast<int >(wxLB_NEEDED_SB)));
49153 }
49154 {
49155 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int(static_cast<int >(wxLB_ALWAYS_SB)));
49156 }
49157 {
49158 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int(static_cast<int >(wxLB_SORT)));
49159 }
49160 {
49161 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int(static_cast<int >(wxLB_SINGLE)));
49162 }
49163 {
49164 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int(static_cast<int >(wxLB_MULTIPLE)));
49165 }
49166 {
49167 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int(static_cast<int >(wxLB_EXTENDED)));
49168 }
49169 {
49170 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int(static_cast<int >(wxLB_OWNERDRAW)));
49171 }
49172 {
49173 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int(static_cast<int >(wxLB_HSCROLL)));
49174 }
49175 {
49176 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int(static_cast<int >(wxPROCESS_ENTER)));
49177 }
49178 {
49179 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int(static_cast<int >(wxPASSWORD)));
49180 }
49181 {
49182 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int(static_cast<int >(wxCB_SIMPLE)));
49183 }
49184 {
49185 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int(static_cast<int >(wxCB_DROPDOWN)));
49186 }
49187 {
49188 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int(static_cast<int >(wxCB_SORT)));
49189 }
49190 {
49191 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int(static_cast<int >(wxCB_READONLY)));
49192 }
49193 {
49194 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int(static_cast<int >(wxRA_HORIZONTAL)));
49195 }
49196 {
49197 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int(static_cast<int >(wxRA_VERTICAL)));
49198 }
49199 {
49200 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int(static_cast<int >(wxRA_SPECIFY_ROWS)));
49201 }
49202 {
49203 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int(static_cast<int >(wxRA_SPECIFY_COLS)));
49204 }
49205 {
49206 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int(static_cast<int >(wxRA_USE_CHECKBOX)));
49207 }
49208 {
49209 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int(static_cast<int >(wxRB_GROUP)));
49210 }
49211 {
49212 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int(static_cast<int >(wxRB_SINGLE)));
49213 }
49214 {
49215 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int(static_cast<int >(wxSB_HORIZONTAL)));
49216 }
49217 {
49218 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int(static_cast<int >(wxSB_VERTICAL)));
49219 }
49220 {
49221 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int(static_cast<int >(wxRB_USE_CHECKBOX)));
49222 }
49223 {
49224 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int(static_cast<int >(wxST_SIZEGRIP)));
49225 }
49226 {
49227 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int(static_cast<int >(wxST_NO_AUTORESIZE)));
49228 }
49229 {
49230 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int(static_cast<int >(wxFLOOD_SURFACE)));
49231 }
49232 {
49233 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int(static_cast<int >(wxFLOOD_BORDER)));
49234 }
49235 {
49236 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int(static_cast<int >(wxODDEVEN_RULE)));
49237 }
49238 {
49239 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int(static_cast<int >(wxWINDING_RULE)));
49240 }
49241 {
49242 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int(static_cast<int >(wxTOOL_TOP)));
49243 }
49244 {
49245 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int(static_cast<int >(wxTOOL_BOTTOM)));
49246 }
49247 {
49248 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int(static_cast<int >(wxTOOL_LEFT)));
49249 }
49250 {
49251 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int(static_cast<int >(wxTOOL_RIGHT)));
49252 }
49253 {
49254 PyDict_SetItemString(d,"OK", SWIG_From_int(static_cast<int >(wxOK)));
49255 }
49256 {
49257 PyDict_SetItemString(d,"YES_NO", SWIG_From_int(static_cast<int >(wxYES_NO)));
49258 }
49259 {
49260 PyDict_SetItemString(d,"CANCEL", SWIG_From_int(static_cast<int >(wxCANCEL)));
49261 }
49262 {
49263 PyDict_SetItemString(d,"YES", SWIG_From_int(static_cast<int >(wxYES)));
49264 }
49265 {
49266 PyDict_SetItemString(d,"NO", SWIG_From_int(static_cast<int >(wxNO)));
49267 }
49268 {
49269 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int(static_cast<int >(wxNO_DEFAULT)));
49270 }
49271 {
49272 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int(static_cast<int >(wxYES_DEFAULT)));
49273 }
49274 {
49275 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int(static_cast<int >(wxICON_EXCLAMATION)));
49276 }
49277 {
49278 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int(static_cast<int >(wxICON_HAND)));
49279 }
49280 {
49281 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int(static_cast<int >(wxICON_QUESTION)));
49282 }
49283 {
49284 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int(static_cast<int >(wxICON_INFORMATION)));
49285 }
49286 {
49287 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int(static_cast<int >(wxICON_STOP)));
49288 }
49289 {
49290 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int(static_cast<int >(wxICON_ASTERISK)));
49291 }
49292 {
49293 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int(static_cast<int >(wxICON_MASK)));
49294 }
49295 {
49296 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int(static_cast<int >(wxICON_WARNING)));
49297 }
49298 {
49299 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int(static_cast<int >(wxICON_ERROR)));
49300 }
49301 {
49302 PyDict_SetItemString(d,"FORWARD", SWIG_From_int(static_cast<int >(wxFORWARD)));
49303 }
49304 {
49305 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int(static_cast<int >(wxBACKWARD)));
49306 }
49307 {
49308 PyDict_SetItemString(d,"RESET", SWIG_From_int(static_cast<int >(wxRESET)));
49309 }
49310 {
49311 PyDict_SetItemString(d,"HELP", SWIG_From_int(static_cast<int >(wxHELP)));
49312 }
49313 {
49314 PyDict_SetItemString(d,"MORE", SWIG_From_int(static_cast<int >(wxMORE)));
49315 }
49316 {
49317 PyDict_SetItemString(d,"SETUP", SWIG_From_int(static_cast<int >(wxSETUP)));
49318 }
49319 {
49320 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int(static_cast<int >(wxSIZE_AUTO_WIDTH)));
49321 }
49322 {
49323 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int(static_cast<int >(wxSIZE_AUTO_HEIGHT)));
49324 }
49325 {
49326 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int(static_cast<int >(wxSIZE_AUTO)));
49327 }
49328 {
49329 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int(static_cast<int >(wxSIZE_USE_EXISTING)));
49330 }
49331 {
49332 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int(static_cast<int >(wxSIZE_ALLOW_MINUS_ONE)));
49333 }
49334 {
49335 PyDict_SetItemString(d,"SIZE_FORCE", SWIG_From_int(static_cast<int >(wxSIZE_FORCE)));
49336 }
49337 {
49338 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int(static_cast<int >(wxPORTRAIT)));
49339 }
49340 {
49341 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int(static_cast<int >(wxLANDSCAPE)));
49342 }
49343 {
49344 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_HIGH)));
49345 }
49346 {
49347 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_MEDIUM)));
49348 }
49349 {
49350 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_LOW)));
49351 }
49352 {
49353 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_DRAFT)));
49354 }
49355 {
49356 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int(static_cast<int >(wxID_ANY)));
49357 }
49358 {
49359 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int(static_cast<int >(wxID_SEPARATOR)));
49360 }
49361 {
49362 PyDict_SetItemString(d,"ID_NONE", SWIG_From_int(static_cast<int >(wxID_NONE)));
49363 }
49364 {
49365 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int(static_cast<int >(wxID_LOWEST)));
49366 }
49367 {
49368 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int(static_cast<int >(wxID_OPEN)));
49369 }
49370 {
49371 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int(static_cast<int >(wxID_CLOSE)));
49372 }
49373 {
49374 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int(static_cast<int >(wxID_NEW)));
49375 }
49376 {
49377 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int(static_cast<int >(wxID_SAVE)));
49378 }
49379 {
49380 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int(static_cast<int >(wxID_SAVEAS)));
49381 }
49382 {
49383 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int(static_cast<int >(wxID_REVERT)));
49384 }
49385 {
49386 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int(static_cast<int >(wxID_EXIT)));
49387 }
49388 {
49389 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int(static_cast<int >(wxID_UNDO)));
49390 }
49391 {
49392 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int(static_cast<int >(wxID_REDO)));
49393 }
49394 {
49395 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int(static_cast<int >(wxID_HELP)));
49396 }
49397 {
49398 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int(static_cast<int >(wxID_PRINT)));
49399 }
49400 {
49401 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int(static_cast<int >(wxID_PRINT_SETUP)));
49402 }
49403 {
49404 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int(static_cast<int >(wxID_PREVIEW)));
49405 }
49406 {
49407 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int(static_cast<int >(wxID_ABOUT)));
49408 }
49409 {
49410 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int(static_cast<int >(wxID_HELP_CONTENTS)));
49411 }
49412 {
49413 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int(static_cast<int >(wxID_HELP_COMMANDS)));
49414 }
49415 {
49416 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int(static_cast<int >(wxID_HELP_PROCEDURES)));
49417 }
49418 {
49419 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int(static_cast<int >(wxID_HELP_CONTEXT)));
49420 }
49421 {
49422 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int(static_cast<int >(wxID_CLOSE_ALL)));
49423 }
49424 {
49425 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int(static_cast<int >(wxID_PREFERENCES)));
49426 }
49427 {
49428 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int(static_cast<int >(wxID_CUT)));
49429 }
49430 {
49431 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int(static_cast<int >(wxID_COPY)));
49432 }
49433 {
49434 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int(static_cast<int >(wxID_PASTE)));
49435 }
49436 {
49437 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int(static_cast<int >(wxID_CLEAR)));
49438 }
49439 {
49440 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int(static_cast<int >(wxID_FIND)));
49441 }
49442 {
49443 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int(static_cast<int >(wxID_DUPLICATE)));
49444 }
49445 {
49446 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int(static_cast<int >(wxID_SELECTALL)));
49447 }
49448 {
49449 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int(static_cast<int >(wxID_DELETE)));
49450 }
49451 {
49452 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int(static_cast<int >(wxID_REPLACE)));
49453 }
49454 {
49455 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int(static_cast<int >(wxID_REPLACE_ALL)));
49456 }
49457 {
49458 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int(static_cast<int >(wxID_PROPERTIES)));
49459 }
49460 {
49461 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int(static_cast<int >(wxID_VIEW_DETAILS)));
49462 }
49463 {
49464 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int(static_cast<int >(wxID_VIEW_LARGEICONS)));
49465 }
49466 {
49467 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int(static_cast<int >(wxID_VIEW_SMALLICONS)));
49468 }
49469 {
49470 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int(static_cast<int >(wxID_VIEW_LIST)));
49471 }
49472 {
49473 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTDATE)));
49474 }
49475 {
49476 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTNAME)));
49477 }
49478 {
49479 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTSIZE)));
49480 }
49481 {
49482 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTTYPE)));
49483 }
49484 {
49485 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int(static_cast<int >(wxID_FILE1)));
49486 }
49487 {
49488 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int(static_cast<int >(wxID_FILE2)));
49489 }
49490 {
49491 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int(static_cast<int >(wxID_FILE3)));
49492 }
49493 {
49494 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int(static_cast<int >(wxID_FILE4)));
49495 }
49496 {
49497 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int(static_cast<int >(wxID_FILE5)));
49498 }
49499 {
49500 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int(static_cast<int >(wxID_FILE6)));
49501 }
49502 {
49503 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int(static_cast<int >(wxID_FILE7)));
49504 }
49505 {
49506 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int(static_cast<int >(wxID_FILE8)));
49507 }
49508 {
49509 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int(static_cast<int >(wxID_FILE9)));
49510 }
49511 {
49512 PyDict_SetItemString(d,"ID_OK", SWIG_From_int(static_cast<int >(wxID_OK)));
49513 }
49514 {
49515 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int(static_cast<int >(wxID_CANCEL)));
49516 }
49517 {
49518 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int(static_cast<int >(wxID_APPLY)));
49519 }
49520 {
49521 PyDict_SetItemString(d,"ID_YES", SWIG_From_int(static_cast<int >(wxID_YES)));
49522 }
49523 {
49524 PyDict_SetItemString(d,"ID_NO", SWIG_From_int(static_cast<int >(wxID_NO)));
49525 }
49526 {
49527 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int(static_cast<int >(wxID_STATIC)));
49528 }
49529 {
49530 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int(static_cast<int >(wxID_FORWARD)));
49531 }
49532 {
49533 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int(static_cast<int >(wxID_BACKWARD)));
49534 }
49535 {
49536 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int(static_cast<int >(wxID_DEFAULT)));
49537 }
49538 {
49539 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int(static_cast<int >(wxID_MORE)));
49540 }
49541 {
49542 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int(static_cast<int >(wxID_SETUP)));
49543 }
49544 {
49545 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int(static_cast<int >(wxID_RESET)));
49546 }
49547 {
49548 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int(static_cast<int >(wxID_CONTEXT_HELP)));
49549 }
49550 {
49551 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int(static_cast<int >(wxID_YESTOALL)));
49552 }
49553 {
49554 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int(static_cast<int >(wxID_NOTOALL)));
49555 }
49556 {
49557 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int(static_cast<int >(wxID_ABORT)));
49558 }
49559 {
49560 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int(static_cast<int >(wxID_RETRY)));
49561 }
49562 {
49563 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int(static_cast<int >(wxID_IGNORE)));
49564 }
49565 {
49566 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int(static_cast<int >(wxID_ADD)));
49567 }
49568 {
49569 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int(static_cast<int >(wxID_REMOVE)));
49570 }
49571 {
49572 PyDict_SetItemString(d,"ID_UP", SWIG_From_int(static_cast<int >(wxID_UP)));
49573 }
49574 {
49575 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int(static_cast<int >(wxID_DOWN)));
49576 }
49577 {
49578 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int(static_cast<int >(wxID_HOME)));
49579 }
49580 {
49581 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int(static_cast<int >(wxID_REFRESH)));
49582 }
49583 {
49584 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int(static_cast<int >(wxID_STOP)));
49585 }
49586 {
49587 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int(static_cast<int >(wxID_INDEX)));
49588 }
49589 {
49590 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int(static_cast<int >(wxID_BOLD)));
49591 }
49592 {
49593 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int(static_cast<int >(wxID_ITALIC)));
49594 }
49595 {
49596 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_CENTER)));
49597 }
49598 {
49599 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_FILL)));
49600 }
49601 {
49602 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_RIGHT)));
49603 }
49604 {
49605 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_LEFT)));
49606 }
49607 {
49608 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int(static_cast<int >(wxID_UNDERLINE)));
49609 }
49610 {
49611 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int(static_cast<int >(wxID_INDENT)));
49612 }
49613 {
49614 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int(static_cast<int >(wxID_UNINDENT)));
49615 }
49616 {
49617 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int(static_cast<int >(wxID_ZOOM_100)));
49618 }
49619 {
49620 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int(static_cast<int >(wxID_ZOOM_FIT)));
49621 }
49622 {
49623 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int(static_cast<int >(wxID_ZOOM_IN)));
49624 }
49625 {
49626 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int(static_cast<int >(wxID_ZOOM_OUT)));
49627 }
49628 {
49629 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int(static_cast<int >(wxID_UNDELETE)));
49630 }
49631 {
49632 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int(static_cast<int >(wxID_REVERT_TO_SAVED)));
49633 }
49634 {
49635 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int(static_cast<int >(wxID_HIGHEST)));
49636 }
49637 {
49638 PyDict_SetItemString(d,"OPEN", SWIG_From_int(static_cast<int >(wxOPEN)));
49639 }
49640 {
49641 PyDict_SetItemString(d,"SAVE", SWIG_From_int(static_cast<int >(wxSAVE)));
49642 }
49643 {
49644 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int(static_cast<int >(wxHIDE_READONLY)));
49645 }
49646 {
49647 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int(static_cast<int >(wxOVERWRITE_PROMPT)));
49648 }
49649 {
49650 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int(static_cast<int >(wxFILE_MUST_EXIST)));
49651 }
49652 {
49653 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int(static_cast<int >(wxMULTIPLE)));
49654 }
49655 {
49656 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int(static_cast<int >(wxCHANGE_DIR)));
49657 }
49658 {
49659 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int(static_cast<int >(wxACCEL_ALT)));
49660 }
49661 {
49662 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int(static_cast<int >(wxACCEL_CTRL)));
49663 }
49664 {
49665 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int(static_cast<int >(wxACCEL_SHIFT)));
49666 }
49667 {
49668 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int(static_cast<int >(wxACCEL_NORMAL)));
49669 }
49670 {
49671 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int(static_cast<int >(wxPD_AUTO_HIDE)));
49672 }
49673 {
49674 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int(static_cast<int >(wxPD_APP_MODAL)));
49675 }
49676 {
49677 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int(static_cast<int >(wxPD_CAN_ABORT)));
49678 }
49679 {
49680 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int(static_cast<int >(wxPD_ELAPSED_TIME)));
49681 }
49682 {
49683 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int(static_cast<int >(wxPD_ESTIMATED_TIME)));
49684 }
49685 {
49686 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int(static_cast<int >(wxPD_REMAINING_TIME)));
49687 }
49688 {
49689 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int(static_cast<int >(wxPD_SMOOTH)));
49690 }
49691 {
49692 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int(static_cast<int >(wxPD_CAN_SKIP)));
49693 }
49694 {
49695 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int(static_cast<int >(wxDD_NEW_DIR_BUTTON)));
49696 }
49697 {
49698 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int(static_cast<int >(wxDD_DEFAULT_STYLE)));
49699 }
49700 {
49701 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int(static_cast<int >(wxMENU_TEAROFF)));
49702 }
49703 {
49704 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int(static_cast<int >(wxMB_DOCKABLE)));
49705 }
49706 {
49707 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int(static_cast<int >(wxNO_FULL_REPAINT_ON_RESIZE)));
49708 }
49709 {
49710 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int(static_cast<int >(wxFULL_REPAINT_ON_RESIZE)));
49711 }
49712 {
49713 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int(static_cast<int >(wxLI_HORIZONTAL)));
49714 }
49715 {
49716 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int(static_cast<int >(wxLI_VERTICAL)));
49717 }
49718 {
49719 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int(static_cast<int >(wxWS_EX_VALIDATE_RECURSIVELY)));
49720 }
49721 {
49722 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int(static_cast<int >(wxWS_EX_BLOCK_EVENTS)));
49723 }
49724 {
49725 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int(static_cast<int >(wxWS_EX_TRANSIENT)));
49726 }
49727 {
49728 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int(static_cast<int >(wxWS_EX_THEMED_BACKGROUND)));
49729 }
49730 {
49731 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int(static_cast<int >(wxWS_EX_PROCESS_IDLE)));
49732 }
49733 {
49734 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int(static_cast<int >(wxWS_EX_PROCESS_UI_UPDATES)));
49735 }
49736 {
49737 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int(static_cast<int >(wxMM_TEXT)));
49738 }
49739 {
49740 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int(static_cast<int >(wxMM_LOMETRIC)));
49741 }
49742 {
49743 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int(static_cast<int >(wxMM_HIMETRIC)));
49744 }
49745 {
49746 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int(static_cast<int >(wxMM_LOENGLISH)));
49747 }
49748 {
49749 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int(static_cast<int >(wxMM_HIENGLISH)));
49750 }
49751 {
49752 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int(static_cast<int >(wxMM_TWIPS)));
49753 }
49754 {
49755 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int(static_cast<int >(wxMM_ISOTROPIC)));
49756 }
49757 {
49758 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int(static_cast<int >(wxMM_ANISOTROPIC)));
49759 }
49760 {
49761 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int(static_cast<int >(wxMM_POINTS)));
49762 }
49763 {
49764 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int(static_cast<int >(wxMM_METRIC)));
49765 }
49766 {
49767 PyDict_SetItemString(d,"CENTRE", SWIG_From_int(static_cast<int >(wxCENTRE)));
49768 }
49769 {
49770 PyDict_SetItemString(d,"CENTER", SWIG_From_int(static_cast<int >(wxCENTER)));
49771 }
49772 {
49773 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int(static_cast<int >(wxHORIZONTAL)));
49774 }
49775 {
49776 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int(static_cast<int >(wxVERTICAL)));
49777 }
49778 {
49779 PyDict_SetItemString(d,"BOTH", SWIG_From_int(static_cast<int >(wxBOTH)));
49780 }
49781 {
49782 PyDict_SetItemString(d,"LEFT", SWIG_From_int(static_cast<int >(wxLEFT)));
49783 }
49784 {
49785 PyDict_SetItemString(d,"RIGHT", SWIG_From_int(static_cast<int >(wxRIGHT)));
49786 }
49787 {
49788 PyDict_SetItemString(d,"UP", SWIG_From_int(static_cast<int >(wxUP)));
49789 }
49790 {
49791 PyDict_SetItemString(d,"DOWN", SWIG_From_int(static_cast<int >(wxDOWN)));
49792 }
49793 {
49794 PyDict_SetItemString(d,"TOP", SWIG_From_int(static_cast<int >(wxTOP)));
49795 }
49796 {
49797 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int(static_cast<int >(wxBOTTOM)));
49798 }
49799 {
49800 PyDict_SetItemString(d,"NORTH", SWIG_From_int(static_cast<int >(wxNORTH)));
49801 }
49802 {
49803 PyDict_SetItemString(d,"SOUTH", SWIG_From_int(static_cast<int >(wxSOUTH)));
49804 }
49805 {
49806 PyDict_SetItemString(d,"WEST", SWIG_From_int(static_cast<int >(wxWEST)));
49807 }
49808 {
49809 PyDict_SetItemString(d,"EAST", SWIG_From_int(static_cast<int >(wxEAST)));
49810 }
49811 {
49812 PyDict_SetItemString(d,"ALL", SWIG_From_int(static_cast<int >(wxALL)));
49813 }
49814 {
49815 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int(static_cast<int >(wxALIGN_NOT)));
49816 }
49817 {
49818 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTER_HORIZONTAL)));
49819 }
49820 {
49821 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE_HORIZONTAL)));
49822 }
49823 {
49824 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int(static_cast<int >(wxALIGN_LEFT)));
49825 }
49826 {
49827 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int(static_cast<int >(wxALIGN_TOP)));
49828 }
49829 {
49830 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int(static_cast<int >(wxALIGN_RIGHT)));
49831 }
49832 {
49833 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int(static_cast<int >(wxALIGN_BOTTOM)));
49834 }
49835 {
49836 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTER_VERTICAL)));
49837 }
49838 {
49839 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE_VERTICAL)));
49840 }
49841 {
49842 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int(static_cast<int >(wxALIGN_CENTER)));
49843 }
49844 {
49845 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE)));
49846 }
49847 {
49848 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int(static_cast<int >(wxALIGN_MASK)));
49849 }
49850 {
49851 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int(static_cast<int >(wxSTRETCH_NOT)));
49852 }
49853 {
49854 PyDict_SetItemString(d,"SHRINK", SWIG_From_int(static_cast<int >(wxSHRINK)));
49855 }
49856 {
49857 PyDict_SetItemString(d,"GROW", SWIG_From_int(static_cast<int >(wxGROW)));
49858 }
49859 {
49860 PyDict_SetItemString(d,"EXPAND", SWIG_From_int(static_cast<int >(wxEXPAND)));
49861 }
49862 {
49863 PyDict_SetItemString(d,"SHAPED", SWIG_From_int(static_cast<int >(wxSHAPED)));
49864 }
49865 {
49866 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int(static_cast<int >(wxFIXED_MINSIZE)));
49867 }
49868 {
49869 PyDict_SetItemString(d,"TILE", SWIG_From_int(static_cast<int >(wxTILE)));
49870 }
49871 {
49872 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int(static_cast<int >(wxADJUST_MINSIZE)));
49873 }
49874 {
49875 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int(static_cast<int >(wxBORDER_DEFAULT)));
49876 }
49877 {
49878 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int(static_cast<int >(wxBORDER_NONE)));
49879 }
49880 {
49881 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int(static_cast<int >(wxBORDER_STATIC)));
49882 }
49883 {
49884 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int(static_cast<int >(wxBORDER_SIMPLE)));
49885 }
49886 {
49887 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int(static_cast<int >(wxBORDER_RAISED)));
49888 }
49889 {
49890 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int(static_cast<int >(wxBORDER_SUNKEN)));
49891 }
49892 {
49893 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int(static_cast<int >(wxBORDER_DOUBLE)));
49894 }
49895 {
49896 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int(static_cast<int >(wxBORDER_MASK)));
49897 }
49898 {
49899 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int(static_cast<int >(wxBG_STYLE_SYSTEM)));
49900 }
49901 {
49902 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int(static_cast<int >(wxBG_STYLE_COLOUR)));
49903 }
49904 {
49905 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int(static_cast<int >(wxBG_STYLE_CUSTOM)));
49906 }
49907 {
49908 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int(static_cast<int >(wxDEFAULT)));
49909 }
49910 {
49911 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int(static_cast<int >(wxDECORATIVE)));
49912 }
49913 {
49914 PyDict_SetItemString(d,"ROMAN", SWIG_From_int(static_cast<int >(wxROMAN)));
49915 }
49916 {
49917 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int(static_cast<int >(wxSCRIPT)));
49918 }
49919 {
49920 PyDict_SetItemString(d,"SWISS", SWIG_From_int(static_cast<int >(wxSWISS)));
49921 }
49922 {
49923 PyDict_SetItemString(d,"MODERN", SWIG_From_int(static_cast<int >(wxMODERN)));
49924 }
49925 {
49926 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int(static_cast<int >(wxTELETYPE)));
49927 }
49928 {
49929 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int(static_cast<int >(wxVARIABLE)));
49930 }
49931 {
49932 PyDict_SetItemString(d,"FIXED", SWIG_From_int(static_cast<int >(wxFIXED)));
49933 }
49934 {
49935 PyDict_SetItemString(d,"NORMAL", SWIG_From_int(static_cast<int >(wxNORMAL)));
49936 }
49937 {
49938 PyDict_SetItemString(d,"LIGHT", SWIG_From_int(static_cast<int >(wxLIGHT)));
49939 }
49940 {
49941 PyDict_SetItemString(d,"BOLD", SWIG_From_int(static_cast<int >(wxBOLD)));
49942 }
49943 {
49944 PyDict_SetItemString(d,"ITALIC", SWIG_From_int(static_cast<int >(wxITALIC)));
49945 }
49946 {
49947 PyDict_SetItemString(d,"SLANT", SWIG_From_int(static_cast<int >(wxSLANT)));
49948 }
49949 {
49950 PyDict_SetItemString(d,"SOLID", SWIG_From_int(static_cast<int >(wxSOLID)));
49951 }
49952 {
49953 PyDict_SetItemString(d,"DOT", SWIG_From_int(static_cast<int >(wxDOT)));
49954 }
49955 {
49956 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int(static_cast<int >(wxLONG_DASH)));
49957 }
49958 {
49959 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int(static_cast<int >(wxSHORT_DASH)));
49960 }
49961 {
49962 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int(static_cast<int >(wxDOT_DASH)));
49963 }
49964 {
49965 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int(static_cast<int >(wxUSER_DASH)));
49966 }
49967 {
49968 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int(static_cast<int >(wxTRANSPARENT)));
49969 }
49970 {
49971 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int(static_cast<int >(wxSTIPPLE)));
49972 }
49973 {
49974 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int(static_cast<int >(wxSTIPPLE_MASK)));
49975 }
49976 {
49977 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int(static_cast<int >(wxSTIPPLE_MASK_OPAQUE)));
49978 }
49979 {
49980 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int(static_cast<int >(wxBDIAGONAL_HATCH)));
49981 }
49982 {
49983 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int(static_cast<int >(wxCROSSDIAG_HATCH)));
49984 }
49985 {
49986 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int(static_cast<int >(wxFDIAGONAL_HATCH)));
49987 }
49988 {
49989 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int(static_cast<int >(wxCROSS_HATCH)));
49990 }
49991 {
49992 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int(static_cast<int >(wxHORIZONTAL_HATCH)));
49993 }
49994 {
49995 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int(static_cast<int >(wxVERTICAL_HATCH)));
49996 }
49997 {
49998 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int(static_cast<int >(wxJOIN_BEVEL)));
49999 }
50000 {
50001 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int(static_cast<int >(wxJOIN_MITER)));
50002 }
50003 {
50004 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int(static_cast<int >(wxJOIN_ROUND)));
50005 }
50006 {
50007 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int(static_cast<int >(wxCAP_ROUND)));
50008 }
50009 {
50010 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int(static_cast<int >(wxCAP_PROJECTING)));
50011 }
50012 {
50013 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int(static_cast<int >(wxCAP_BUTT)));
50014 }
50015 {
50016 PyDict_SetItemString(d,"CLEAR", SWIG_From_int(static_cast<int >(wxCLEAR)));
50017 }
50018 {
50019 PyDict_SetItemString(d,"XOR", SWIG_From_int(static_cast<int >(wxXOR)));
50020 }
50021 {
50022 PyDict_SetItemString(d,"INVERT", SWIG_From_int(static_cast<int >(wxINVERT)));
50023 }
50024 {
50025 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int(static_cast<int >(wxOR_REVERSE)));
50026 }
50027 {
50028 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int(static_cast<int >(wxAND_REVERSE)));
50029 }
50030 {
50031 PyDict_SetItemString(d,"COPY", SWIG_From_int(static_cast<int >(wxCOPY)));
50032 }
50033 {
50034 PyDict_SetItemString(d,"AND", SWIG_From_int(static_cast<int >(wxAND)));
50035 }
50036 {
50037 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int(static_cast<int >(wxAND_INVERT)));
50038 }
50039 {
50040 PyDict_SetItemString(d,"NO_OP", SWIG_From_int(static_cast<int >(wxNO_OP)));
50041 }
50042 {
50043 PyDict_SetItemString(d,"NOR", SWIG_From_int(static_cast<int >(wxNOR)));
50044 }
50045 {
50046 PyDict_SetItemString(d,"EQUIV", SWIG_From_int(static_cast<int >(wxEQUIV)));
50047 }
50048 {
50049 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int(static_cast<int >(wxSRC_INVERT)));
50050 }
50051 {
50052 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int(static_cast<int >(wxOR_INVERT)));
50053 }
50054 {
50055 PyDict_SetItemString(d,"NAND", SWIG_From_int(static_cast<int >(wxNAND)));
50056 }
50057 {
50058 PyDict_SetItemString(d,"OR", SWIG_From_int(static_cast<int >(wxOR)));
50059 }
50060 {
50061 PyDict_SetItemString(d,"SET", SWIG_From_int(static_cast<int >(wxSET)));
50062 }
50063 {
50064 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int(static_cast<int >(WXK_BACK)));
50065 }
50066 {
50067 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int(static_cast<int >(WXK_TAB)));
50068 }
50069 {
50070 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int(static_cast<int >(WXK_RETURN)));
50071 }
50072 {
50073 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int(static_cast<int >(WXK_ESCAPE)));
50074 }
50075 {
50076 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int(static_cast<int >(WXK_SPACE)));
50077 }
50078 {
50079 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int(static_cast<int >(WXK_DELETE)));
50080 }
50081 {
50082 PyDict_SetItemString(d,"WXK_START", SWIG_From_int(static_cast<int >(WXK_START)));
50083 }
50084 {
50085 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int(static_cast<int >(WXK_LBUTTON)));
50086 }
50087 {
50088 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int(static_cast<int >(WXK_RBUTTON)));
50089 }
50090 {
50091 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int(static_cast<int >(WXK_CANCEL)));
50092 }
50093 {
50094 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int(static_cast<int >(WXK_MBUTTON)));
50095 }
50096 {
50097 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int(static_cast<int >(WXK_CLEAR)));
50098 }
50099 {
50100 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int(static_cast<int >(WXK_SHIFT)));
50101 }
50102 {
50103 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int(static_cast<int >(WXK_ALT)));
50104 }
50105 {
50106 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int(static_cast<int >(WXK_CONTROL)));
50107 }
50108 {
50109 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int(static_cast<int >(WXK_MENU)));
50110 }
50111 {
50112 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int(static_cast<int >(WXK_PAUSE)));
50113 }
50114 {
50115 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int(static_cast<int >(WXK_CAPITAL)));
50116 }
50117 {
50118 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int(static_cast<int >(WXK_PRIOR)));
50119 }
50120 {
50121 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int(static_cast<int >(WXK_NEXT)));
50122 }
50123 {
50124 PyDict_SetItemString(d,"WXK_END", SWIG_From_int(static_cast<int >(WXK_END)));
50125 }
50126 {
50127 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int(static_cast<int >(WXK_HOME)));
50128 }
50129 {
50130 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int(static_cast<int >(WXK_LEFT)));
50131 }
50132 {
50133 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int(static_cast<int >(WXK_UP)));
50134 }
50135 {
50136 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int(static_cast<int >(WXK_RIGHT)));
50137 }
50138 {
50139 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int(static_cast<int >(WXK_DOWN)));
50140 }
50141 {
50142 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int(static_cast<int >(WXK_SELECT)));
50143 }
50144 {
50145 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int(static_cast<int >(WXK_PRINT)));
50146 }
50147 {
50148 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int(static_cast<int >(WXK_EXECUTE)));
50149 }
50150 {
50151 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int(static_cast<int >(WXK_SNAPSHOT)));
50152 }
50153 {
50154 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int(static_cast<int >(WXK_INSERT)));
50155 }
50156 {
50157 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int(static_cast<int >(WXK_HELP)));
50158 }
50159 {
50160 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int(static_cast<int >(WXK_NUMPAD0)));
50161 }
50162 {
50163 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int(static_cast<int >(WXK_NUMPAD1)));
50164 }
50165 {
50166 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int(static_cast<int >(WXK_NUMPAD2)));
50167 }
50168 {
50169 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int(static_cast<int >(WXK_NUMPAD3)));
50170 }
50171 {
50172 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int(static_cast<int >(WXK_NUMPAD4)));
50173 }
50174 {
50175 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int(static_cast<int >(WXK_NUMPAD5)));
50176 }
50177 {
50178 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int(static_cast<int >(WXK_NUMPAD6)));
50179 }
50180 {
50181 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int(static_cast<int >(WXK_NUMPAD7)));
50182 }
50183 {
50184 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int(static_cast<int >(WXK_NUMPAD8)));
50185 }
50186 {
50187 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int(static_cast<int >(WXK_NUMPAD9)));
50188 }
50189 {
50190 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int(static_cast<int >(WXK_MULTIPLY)));
50191 }
50192 {
50193 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int(static_cast<int >(WXK_ADD)));
50194 }
50195 {
50196 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int(static_cast<int >(WXK_SEPARATOR)));
50197 }
50198 {
50199 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int(static_cast<int >(WXK_SUBTRACT)));
50200 }
50201 {
50202 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int(static_cast<int >(WXK_DECIMAL)));
50203 }
50204 {
50205 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int(static_cast<int >(WXK_DIVIDE)));
50206 }
50207 {
50208 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int(static_cast<int >(WXK_F1)));
50209 }
50210 {
50211 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int(static_cast<int >(WXK_F2)));
50212 }
50213 {
50214 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int(static_cast<int >(WXK_F3)));
50215 }
50216 {
50217 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int(static_cast<int >(WXK_F4)));
50218 }
50219 {
50220 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int(static_cast<int >(WXK_F5)));
50221 }
50222 {
50223 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int(static_cast<int >(WXK_F6)));
50224 }
50225 {
50226 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int(static_cast<int >(WXK_F7)));
50227 }
50228 {
50229 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int(static_cast<int >(WXK_F8)));
50230 }
50231 {
50232 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int(static_cast<int >(WXK_F9)));
50233 }
50234 {
50235 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int(static_cast<int >(WXK_F10)));
50236 }
50237 {
50238 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int(static_cast<int >(WXK_F11)));
50239 }
50240 {
50241 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int(static_cast<int >(WXK_F12)));
50242 }
50243 {
50244 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int(static_cast<int >(WXK_F13)));
50245 }
50246 {
50247 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int(static_cast<int >(WXK_F14)));
50248 }
50249 {
50250 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int(static_cast<int >(WXK_F15)));
50251 }
50252 {
50253 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int(static_cast<int >(WXK_F16)));
50254 }
50255 {
50256 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int(static_cast<int >(WXK_F17)));
50257 }
50258 {
50259 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int(static_cast<int >(WXK_F18)));
50260 }
50261 {
50262 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int(static_cast<int >(WXK_F19)));
50263 }
50264 {
50265 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int(static_cast<int >(WXK_F20)));
50266 }
50267 {
50268 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int(static_cast<int >(WXK_F21)));
50269 }
50270 {
50271 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int(static_cast<int >(WXK_F22)));
50272 }
50273 {
50274 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int(static_cast<int >(WXK_F23)));
50275 }
50276 {
50277 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int(static_cast<int >(WXK_F24)));
50278 }
50279 {
50280 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int(static_cast<int >(WXK_NUMLOCK)));
50281 }
50282 {
50283 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int(static_cast<int >(WXK_SCROLL)));
50284 }
50285 {
50286 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int(static_cast<int >(WXK_PAGEUP)));
50287 }
50288 {
50289 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int(static_cast<int >(WXK_PAGEDOWN)));
50290 }
50291 {
50292 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SPACE)));
50293 }
50294 {
50295 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int(static_cast<int >(WXK_NUMPAD_TAB)));
50296 }
50297 {
50298 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int(static_cast<int >(WXK_NUMPAD_ENTER)));
50299 }
50300 {
50301 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F1)));
50302 }
50303 {
50304 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F2)));
50305 }
50306 {
50307 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F3)));
50308 }
50309 {
50310 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F4)));
50311 }
50312 {
50313 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int(static_cast<int >(WXK_NUMPAD_HOME)));
50314 }
50315 {
50316 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_LEFT)));
50317 }
50318 {
50319 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int(static_cast<int >(WXK_NUMPAD_UP)));
50320 }
50321 {
50322 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_RIGHT)));
50323 }
50324 {
50325 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DOWN)));
50326 }
50327 {
50328 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PRIOR)));
50329 }
50330 {
50331 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PAGEUP)));
50332 }
50333 {
50334 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_NEXT)));
50335 }
50336 {
50337 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PAGEDOWN)));
50338 }
50339 {
50340 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int(static_cast<int >(WXK_NUMPAD_END)));
50341 }
50342 {
50343 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_BEGIN)));
50344 }
50345 {
50346 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_INSERT)));
50347 }
50348 {
50349 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DELETE)));
50350 }
50351 {
50352 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int(static_cast<int >(WXK_NUMPAD_EQUAL)));
50353 }
50354 {
50355 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int(static_cast<int >(WXK_NUMPAD_MULTIPLY)));
50356 }
50357 {
50358 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int(static_cast<int >(WXK_NUMPAD_ADD)));
50359 }
50360 {
50361 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SEPARATOR)));
50362 }
50363 {
50364 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SUBTRACT)));
50365 }
50366 {
50367 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DECIMAL)));
50368 }
50369 {
50370 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DIVIDE)));
50371 }
50372 {
50373 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int(static_cast<int >(WXK_WINDOWS_LEFT)));
50374 }
50375 {
50376 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int(static_cast<int >(WXK_WINDOWS_RIGHT)));
50377 }
50378 {
50379 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int(static_cast<int >(WXK_WINDOWS_MENU)));
50380 }
50381 {
50382 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int(static_cast<int >(WXK_COMMAND)));
50383 }
50384 {
50385 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int(static_cast<int >(WXK_SPECIAL1)));
50386 }
50387 {
50388 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int(static_cast<int >(WXK_SPECIAL2)));
50389 }
50390 {
50391 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int(static_cast<int >(WXK_SPECIAL3)));
50392 }
50393 {
50394 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int(static_cast<int >(WXK_SPECIAL4)));
50395 }
50396 {
50397 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int(static_cast<int >(WXK_SPECIAL5)));
50398 }
50399 {
50400 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int(static_cast<int >(WXK_SPECIAL6)));
50401 }
50402 {
50403 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int(static_cast<int >(WXK_SPECIAL7)));
50404 }
50405 {
50406 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int(static_cast<int >(WXK_SPECIAL8)));
50407 }
50408 {
50409 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int(static_cast<int >(WXK_SPECIAL9)));
50410 }
50411 {
50412 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int(static_cast<int >(WXK_SPECIAL10)));
50413 }
50414 {
50415 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int(static_cast<int >(WXK_SPECIAL11)));
50416 }
50417 {
50418 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int(static_cast<int >(WXK_SPECIAL12)));
50419 }
50420 {
50421 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int(static_cast<int >(WXK_SPECIAL13)));
50422 }
50423 {
50424 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int(static_cast<int >(WXK_SPECIAL14)));
50425 }
50426 {
50427 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int(static_cast<int >(WXK_SPECIAL15)));
50428 }
50429 {
50430 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int(static_cast<int >(WXK_SPECIAL16)));
50431 }
50432 {
50433 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int(static_cast<int >(WXK_SPECIAL17)));
50434 }
50435 {
50436 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int(static_cast<int >(WXK_SPECIAL18)));
50437 }
50438 {
50439 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int(static_cast<int >(WXK_SPECIAL19)));
50440 }
50441 {
50442 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int(static_cast<int >(WXK_SPECIAL20)));
50443 }
50444 {
50445 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int(static_cast<int >(wxPAPER_NONE)));
50446 }
50447 {
50448 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int(static_cast<int >(wxPAPER_LETTER)));
50449 }
50450 {
50451 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int(static_cast<int >(wxPAPER_LEGAL)));
50452 }
50453 {
50454 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int(static_cast<int >(wxPAPER_A4)));
50455 }
50456 {
50457 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int(static_cast<int >(wxPAPER_CSHEET)));
50458 }
50459 {
50460 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int(static_cast<int >(wxPAPER_DSHEET)));
50461 }
50462 {
50463 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int(static_cast<int >(wxPAPER_ESHEET)));
50464 }
50465 {
50466 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int(static_cast<int >(wxPAPER_LETTERSMALL)));
50467 }
50468 {
50469 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int(static_cast<int >(wxPAPER_TABLOID)));
50470 }
50471 {
50472 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int(static_cast<int >(wxPAPER_LEDGER)));
50473 }
50474 {
50475 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int(static_cast<int >(wxPAPER_STATEMENT)));
50476 }
50477 {
50478 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int(static_cast<int >(wxPAPER_EXECUTIVE)));
50479 }
50480 {
50481 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int(static_cast<int >(wxPAPER_A3)));
50482 }
50483 {
50484 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int(static_cast<int >(wxPAPER_A4SMALL)));
50485 }
50486 {
50487 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int(static_cast<int >(wxPAPER_A5)));
50488 }
50489 {
50490 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int(static_cast<int >(wxPAPER_B4)));
50491 }
50492 {
50493 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int(static_cast<int >(wxPAPER_B5)));
50494 }
50495 {
50496 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int(static_cast<int >(wxPAPER_FOLIO)));
50497 }
50498 {
50499 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int(static_cast<int >(wxPAPER_QUARTO)));
50500 }
50501 {
50502 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int(static_cast<int >(wxPAPER_10X14)));
50503 }
50504 {
50505 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int(static_cast<int >(wxPAPER_11X17)));
50506 }
50507 {
50508 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int(static_cast<int >(wxPAPER_NOTE)));
50509 }
50510 {
50511 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int(static_cast<int >(wxPAPER_ENV_9)));
50512 }
50513 {
50514 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int(static_cast<int >(wxPAPER_ENV_10)));
50515 }
50516 {
50517 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int(static_cast<int >(wxPAPER_ENV_11)));
50518 }
50519 {
50520 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int(static_cast<int >(wxPAPER_ENV_12)));
50521 }
50522 {
50523 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int(static_cast<int >(wxPAPER_ENV_14)));
50524 }
50525 {
50526 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int(static_cast<int >(wxPAPER_ENV_DL)));
50527 }
50528 {
50529 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C5)));
50530 }
50531 {
50532 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C3)));
50533 }
50534 {
50535 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C4)));
50536 }
50537 {
50538 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C6)));
50539 }
50540 {
50541 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C65)));
50542 }
50543 {
50544 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B4)));
50545 }
50546 {
50547 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B5)));
50548 }
50549 {
50550 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B6)));
50551 }
50552 {
50553 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int(static_cast<int >(wxPAPER_ENV_ITALY)));
50554 }
50555 {
50556 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int(static_cast<int >(wxPAPER_ENV_MONARCH)));
50557 }
50558 {
50559 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int(static_cast<int >(wxPAPER_ENV_PERSONAL)));
50560 }
50561 {
50562 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_US)));
50563 }
50564 {
50565 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_STD_GERMAN)));
50566 }
50567 {
50568 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_LGL_GERMAN)));
50569 }
50570 {
50571 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int(static_cast<int >(wxPAPER_ISO_B4)));
50572 }
50573 {
50574 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int(static_cast<int >(wxPAPER_JAPANESE_POSTCARD)));
50575 }
50576 {
50577 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int(static_cast<int >(wxPAPER_9X11)));
50578 }
50579 {
50580 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int(static_cast<int >(wxPAPER_10X11)));
50581 }
50582 {
50583 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int(static_cast<int >(wxPAPER_15X11)));
50584 }
50585 {
50586 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int(static_cast<int >(wxPAPER_ENV_INVITE)));
50587 }
50588 {
50589 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_EXTRA)));
50590 }
50591 {
50592 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_LEGAL_EXTRA)));
50593 }
50594 {
50595 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_TABLOID_EXTRA)));
50596 }
50597 {
50598 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A4_EXTRA)));
50599 }
50600 {
50601 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_TRANSVERSE)));
50602 }
50603 {
50604 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A4_TRANSVERSE)));
50605 }
50606 {
50607 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
50608 }
50609 {
50610 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_A_PLUS)));
50611 }
50612 {
50613 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_B_PLUS)));
50614 }
50615 {
50616 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_PLUS)));
50617 }
50618 {
50619 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_A4_PLUS)));
50620 }
50621 {
50622 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A5_TRANSVERSE)));
50623 }
50624 {
50625 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_B5_TRANSVERSE)));
50626 }
50627 {
50628 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A3_EXTRA)));
50629 }
50630 {
50631 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A5_EXTRA)));
50632 }
50633 {
50634 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_B5_EXTRA)));
50635 }
50636 {
50637 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int(static_cast<int >(wxPAPER_A2)));
50638 }
50639 {
50640 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A3_TRANSVERSE)));
50641 }
50642 {
50643 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
50644 }
50645 {
50646 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD", SWIG_From_int(static_cast<int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
50647 }
50648 {
50649 PyDict_SetItemString(d,"PAPER_A6", SWIG_From_int(static_cast<int >(wxPAPER_A6)));
50650 }
50651 {
50652 PyDict_SetItemString(d,"PAPER_JENV_KAKU2", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU2)));
50653 }
50654 {
50655 PyDict_SetItemString(d,"PAPER_JENV_KAKU3", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU3)));
50656 }
50657 {
50658 PyDict_SetItemString(d,"PAPER_JENV_CHOU3", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU3)));
50659 }
50660 {
50661 PyDict_SetItemString(d,"PAPER_JENV_CHOU4", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU4)));
50662 }
50663 {
50664 PyDict_SetItemString(d,"PAPER_LETTER_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_ROTATED)));
50665 }
50666 {
50667 PyDict_SetItemString(d,"PAPER_A3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A3_ROTATED)));
50668 }
50669 {
50670 PyDict_SetItemString(d,"PAPER_A4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A4_ROTATED)));
50671 }
50672 {
50673 PyDict_SetItemString(d,"PAPER_A5_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A5_ROTATED)));
50674 }
50675 {
50676 PyDict_SetItemString(d,"PAPER_B4_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B4_JIS_ROTATED)));
50677 }
50678 {
50679 PyDict_SetItemString(d,"PAPER_B5_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B5_JIS_ROTATED)));
50680 }
50681 {
50682 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
50683 }
50684 {
50685 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
50686 }
50687 {
50688 PyDict_SetItemString(d,"PAPER_A6_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A6_ROTATED)));
50689 }
50690 {
50691 PyDict_SetItemString(d,"PAPER_JENV_KAKU2_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU2_ROTATED)));
50692 }
50693 {
50694 PyDict_SetItemString(d,"PAPER_JENV_KAKU3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU3_ROTATED)));
50695 }
50696 {
50697 PyDict_SetItemString(d,"PAPER_JENV_CHOU3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU3_ROTATED)));
50698 }
50699 {
50700 PyDict_SetItemString(d,"PAPER_JENV_CHOU4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU4_ROTATED)));
50701 }
50702 {
50703 PyDict_SetItemString(d,"PAPER_B6_JIS", SWIG_From_int(static_cast<int >(wxPAPER_B6_JIS)));
50704 }
50705 {
50706 PyDict_SetItemString(d,"PAPER_B6_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B6_JIS_ROTATED)));
50707 }
50708 {
50709 PyDict_SetItemString(d,"PAPER_12X11", SWIG_From_int(static_cast<int >(wxPAPER_12X11)));
50710 }
50711 {
50712 PyDict_SetItemString(d,"PAPER_JENV_YOU4", SWIG_From_int(static_cast<int >(wxPAPER_JENV_YOU4)));
50713 }
50714 {
50715 PyDict_SetItemString(d,"PAPER_JENV_YOU4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_YOU4_ROTATED)));
50716 }
50717 {
50718 PyDict_SetItemString(d,"PAPER_P16K", SWIG_From_int(static_cast<int >(wxPAPER_P16K)));
50719 }
50720 {
50721 PyDict_SetItemString(d,"PAPER_P32K", SWIG_From_int(static_cast<int >(wxPAPER_P32K)));
50722 }
50723 {
50724 PyDict_SetItemString(d,"PAPER_P32KBIG", SWIG_From_int(static_cast<int >(wxPAPER_P32KBIG)));
50725 }
50726 {
50727 PyDict_SetItemString(d,"PAPER_PENV_1", SWIG_From_int(static_cast<int >(wxPAPER_PENV_1)));
50728 }
50729 {
50730 PyDict_SetItemString(d,"PAPER_PENV_2", SWIG_From_int(static_cast<int >(wxPAPER_PENV_2)));
50731 }
50732 {
50733 PyDict_SetItemString(d,"PAPER_PENV_3", SWIG_From_int(static_cast<int >(wxPAPER_PENV_3)));
50734 }
50735 {
50736 PyDict_SetItemString(d,"PAPER_PENV_4", SWIG_From_int(static_cast<int >(wxPAPER_PENV_4)));
50737 }
50738 {
50739 PyDict_SetItemString(d,"PAPER_PENV_5", SWIG_From_int(static_cast<int >(wxPAPER_PENV_5)));
50740 }
50741 {
50742 PyDict_SetItemString(d,"PAPER_PENV_6", SWIG_From_int(static_cast<int >(wxPAPER_PENV_6)));
50743 }
50744 {
50745 PyDict_SetItemString(d,"PAPER_PENV_7", SWIG_From_int(static_cast<int >(wxPAPER_PENV_7)));
50746 }
50747 {
50748 PyDict_SetItemString(d,"PAPER_PENV_8", SWIG_From_int(static_cast<int >(wxPAPER_PENV_8)));
50749 }
50750 {
50751 PyDict_SetItemString(d,"PAPER_PENV_9", SWIG_From_int(static_cast<int >(wxPAPER_PENV_9)));
50752 }
50753 {
50754 PyDict_SetItemString(d,"PAPER_PENV_10", SWIG_From_int(static_cast<int >(wxPAPER_PENV_10)));
50755 }
50756 {
50757 PyDict_SetItemString(d,"PAPER_P16K_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P16K_ROTATED)));
50758 }
50759 {
50760 PyDict_SetItemString(d,"PAPER_P32K_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P32K_ROTATED)));
50761 }
50762 {
50763 PyDict_SetItemString(d,"PAPER_P32KBIG_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P32KBIG_ROTATED)));
50764 }
50765 {
50766 PyDict_SetItemString(d,"PAPER_PENV_1_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_1_ROTATED)));
50767 }
50768 {
50769 PyDict_SetItemString(d,"PAPER_PENV_2_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_2_ROTATED)));
50770 }
50771 {
50772 PyDict_SetItemString(d,"PAPER_PENV_3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_3_ROTATED)));
50773 }
50774 {
50775 PyDict_SetItemString(d,"PAPER_PENV_4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_4_ROTATED)));
50776 }
50777 {
50778 PyDict_SetItemString(d,"PAPER_PENV_5_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_5_ROTATED)));
50779 }
50780 {
50781 PyDict_SetItemString(d,"PAPER_PENV_6_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_6_ROTATED)));
50782 }
50783 {
50784 PyDict_SetItemString(d,"PAPER_PENV_7_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_7_ROTATED)));
50785 }
50786 {
50787 PyDict_SetItemString(d,"PAPER_PENV_8_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_8_ROTATED)));
50788 }
50789 {
50790 PyDict_SetItemString(d,"PAPER_PENV_9_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_9_ROTATED)));
50791 }
50792 {
50793 PyDict_SetItemString(d,"PAPER_PENV_10_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_10_ROTATED)));
50794 }
50795 {
50796 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int(static_cast<int >(wxDUPLEX_SIMPLEX)));
50797 }
50798 {
50799 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int(static_cast<int >(wxDUPLEX_HORIZONTAL)));
50800 }
50801 {
50802 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int(static_cast<int >(wxDUPLEX_VERTICAL)));
50803 }
50804 {
50805 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int(static_cast<int >(wxITEM_SEPARATOR)));
50806 }
50807 {
50808 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int(static_cast<int >(wxITEM_NORMAL)));
50809 }
50810 {
50811 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int(static_cast<int >(wxITEM_CHECK)));
50812 }
50813 {
50814 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int(static_cast<int >(wxITEM_RADIO)));
50815 }
50816 {
50817 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int(static_cast<int >(wxITEM_MAX)));
50818 }
50819 {
50820 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int(static_cast<int >(wxHT_NOWHERE)));
50821 }
50822 {
50823 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_FIRST)));
50824 }
50825 {
50826 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
50827 }
50828 {
50829 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
50830 }
50831 {
50832 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
50833 }
50834 {
50835 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
50836 }
50837 {
50838 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_THUMB)));
50839 }
50840 {
50841 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_BAR_1)));
50842 }
50843 {
50844 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_BAR_2)));
50845 }
50846 {
50847 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_LAST)));
50848 }
50849 {
50850 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int(static_cast<int >(wxHT_WINDOW_OUTSIDE)));
50851 }
50852 {
50853 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int(static_cast<int >(wxHT_WINDOW_INSIDE)));
50854 }
50855 {
50856 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int(static_cast<int >(wxHT_WINDOW_VERT_SCROLLBAR)));
50857 }
50858 {
50859 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int(static_cast<int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
50860 }
50861 {
50862 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int(static_cast<int >(wxHT_WINDOW_CORNER)));
50863 }
50864 {
50865 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int(static_cast<int >(wxHT_MAX)));
50866 }
50867 {
50868 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int(static_cast<int >(wxMOD_NONE)));
50869 }
50870 {
50871 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int(static_cast<int >(wxMOD_ALT)));
50872 }
50873 {
50874 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int(static_cast<int >(wxMOD_CONTROL)));
50875 }
50876 {
50877 PyDict_SetItemString(d,"MOD_ALTGR", SWIG_From_int(static_cast<int >(wxMOD_ALTGR)));
50878 }
50879 {
50880 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int(static_cast<int >(wxMOD_SHIFT)));
50881 }
50882 {
50883 PyDict_SetItemString(d,"MOD_META", SWIG_From_int(static_cast<int >(wxMOD_META)));
50884 }
50885 {
50886 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int(static_cast<int >(wxMOD_WIN)));
50887 }
50888 {
50889 PyDict_SetItemString(d,"MOD_CMD", SWIG_From_int(static_cast<int >(wxMOD_CMD)));
50890 }
50891 {
50892 PyDict_SetItemString(d,"MOD_ALL", SWIG_From_int(static_cast<int >(wxMOD_ALL)));
50893 }
50894 {
50895 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_NONE)));
50896 }
50897 {
50898 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_RECURSE)));
50899 }
50900 {
50901 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_FROMIDLE)));
50902 }
50903 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
50904 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
50905 {
50906 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_INVALID)));
50907 }
50908 {
50909 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_BMP)));
50910 }
50911 {
50912 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ICO)));
50913 }
50914 {
50915 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_CUR)));
50916 }
50917 {
50918 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XBM)));
50919 }
50920 {
50921 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XBM_DATA)));
50922 }
50923 {
50924 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XPM)));
50925 }
50926 {
50927 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XPM_DATA)));
50928 }
50929 {
50930 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_TIF)));
50931 }
50932 {
50933 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_GIF)));
50934 }
50935 {
50936 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PNG)));
50937 }
50938 {
50939 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_JPEG)));
50940 }
50941 {
50942 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PNM)));
50943 }
50944 {
50945 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PCX)));
50946 }
50947 {
50948 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PICT)));
50949 }
50950 {
50951 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ICON)));
50952 }
50953 {
50954 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ANI)));
50955 }
50956 {
50957 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_IFF)));
50958 }
50959 {
50960 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_MACCURSOR)));
50961 }
50962 {
50963 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ANY)));
50964 }
50965 {
50966 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int(static_cast<int >(wxCURSOR_NONE)));
50967 }
50968 {
50969 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_ARROW)));
50970 }
50971 {
50972 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_RIGHT_ARROW)));
50973 }
50974 {
50975 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int(static_cast<int >(wxCURSOR_BULLSEYE)));
50976 }
50977 {
50978 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int(static_cast<int >(wxCURSOR_CHAR)));
50979 }
50980 {
50981 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int(static_cast<int >(wxCURSOR_CROSS)));
50982 }
50983 {
50984 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int(static_cast<int >(wxCURSOR_HAND)));
50985 }
50986 {
50987 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int(static_cast<int >(wxCURSOR_IBEAM)));
50988 }
50989 {
50990 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_LEFT_BUTTON)));
50991 }
50992 {
50993 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int(static_cast<int >(wxCURSOR_MAGNIFIER)));
50994 }
50995 {
50996 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_MIDDLE_BUTTON)));
50997 }
50998 {
50999 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int(static_cast<int >(wxCURSOR_NO_ENTRY)));
51000 }
51001 {
51002 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int(static_cast<int >(wxCURSOR_PAINT_BRUSH)));
51003 }
51004 {
51005 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int(static_cast<int >(wxCURSOR_PENCIL)));
51006 }
51007 {
51008 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int(static_cast<int >(wxCURSOR_POINT_LEFT)));
51009 }
51010 {
51011 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int(static_cast<int >(wxCURSOR_POINT_RIGHT)));
51012 }
51013 {
51014 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_QUESTION_ARROW)));
51015 }
51016 {
51017 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_RIGHT_BUTTON)));
51018 }
51019 {
51020 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENESW)));
51021 }
51022 {
51023 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENS)));
51024 }
51025 {
51026 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENWSE)));
51027 }
51028 {
51029 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int(static_cast<int >(wxCURSOR_SIZEWE)));
51030 }
51031 {
51032 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int(static_cast<int >(wxCURSOR_SIZING)));
51033 }
51034 {
51035 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int(static_cast<int >(wxCURSOR_SPRAYCAN)));
51036 }
51037 {
51038 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int(static_cast<int >(wxCURSOR_WAIT)));
51039 }
51040 {
51041 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int(static_cast<int >(wxCURSOR_WATCH)));
51042 }
51043 {
51044 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int(static_cast<int >(wxCURSOR_BLANK)));
51045 }
51046 {
51047 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int(static_cast<int >(wxCURSOR_DEFAULT)));
51048 }
51049 {
51050 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_COPY_ARROW)));
51051 }
51052 {
51053 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int(static_cast<int >(wxCURSOR_ARROWWAIT)));
51054 }
51055 {
51056 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int(static_cast<int >(wxCURSOR_MAX)));
51057 }
51058 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
51059 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
51060 {
51061 PyDict_SetItemString(d,"FromStart", SWIG_From_int(static_cast<int >(wxFromStart)));
51062 }
51063 {
51064 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int(static_cast<int >(wxFromCurrent)));
51065 }
51066 {
51067 PyDict_SetItemString(d,"FromEnd", SWIG_From_int(static_cast<int >(wxFromEnd)));
51068 }
51069
51070 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
51071
51072
51073 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
51074
51075 {
51076 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_TRANSPARENT)));
51077 }
51078 {
51079 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_THRESHOLD)));
51080 }
51081 {
51082 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_OPAQUE)));
51083 }
51084 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
51085 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
51086 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
51087 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
51088 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
51089 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
51090 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
51091 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
51092 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
51093 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
51094 {
51095 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int(static_cast<int >(wxIMAGE_RESOLUTION_INCHES)));
51096 }
51097 {
51098 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int(static_cast<int >(wxIMAGE_RESOLUTION_CM)));
51099 }
51100 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
51101 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
51102 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
51103 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
51104 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
51105 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
51106 {
51107 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int(static_cast<int >(wxPNG_TYPE_COLOUR)));
51108 }
51109 {
51110 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int(static_cast<int >(wxPNG_TYPE_GREY)));
51111 }
51112 {
51113 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int(static_cast<int >(wxPNG_TYPE_GREY_RED)));
51114 }
51115 {
51116 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int(static_cast<int >(wxBMP_24BPP)));
51117 }
51118 {
51119 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int(static_cast<int >(wxBMP_8BPP)));
51120 }
51121 {
51122 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int(static_cast<int >(wxBMP_8BPP_GREY)));
51123 }
51124 {
51125 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int(static_cast<int >(wxBMP_8BPP_GRAY)));
51126 }
51127 {
51128 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int(static_cast<int >(wxBMP_8BPP_RED)));
51129 }
51130 {
51131 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int(static_cast<int >(wxBMP_8BPP_PALETTE)));
51132 }
51133 {
51134 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int(static_cast<int >(wxBMP_4BPP)));
51135 }
51136 {
51137 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int(static_cast<int >(wxBMP_1BPP)));
51138 }
51139 {
51140 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int(static_cast<int >(wxBMP_1BPP_BW)));
51141 }
51142 {
51143 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int(static_cast<int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
51144 }
51145 {
51146 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int(static_cast<int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
51147 }
51148 {
51149 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int(static_cast<int >(wxEVENT_PROPAGATE_NONE)));
51150 }
51151 {
51152 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int(static_cast<int >(wxEVENT_PROPAGATE_MAX)));
51153 }
51154 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
51155 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
51156 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
51157 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
51158 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
51159 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
51160 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
51161 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
51162 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
51163 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
51164 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
51165 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
51166 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
51167 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
51168 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
51169 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
51170 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
51171 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
51172 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
51173 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
51174 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
51175 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
51176 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
51177 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
51178 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
51179 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
51180 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
51181 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
51182 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
51183 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
51184 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
51185 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
51186 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
51187 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
51188 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
51189 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
51190 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
51191 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
51192 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
51193 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
51194 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
51195 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
51196 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
51197 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
51198 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
51199 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
51200 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
51201 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
51202 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
51203 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
51204 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
51205 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
51206 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
51207 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
51208 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
51209 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
51210 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
51211 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
51212 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
51213 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
51214 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
51215 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
51216 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
51217 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
51218 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
51219 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
51220 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
51221 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
51222 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
51223 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
51224 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
51225 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
51226 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
51227 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
51228 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
51229 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
51230 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
51231 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
51232 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
51233 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
51234 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
51235 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
51236 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
51237 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
51238 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
51239 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
51240 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
51241 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
51242 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
51243 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
51244 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
51245 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
51246 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
51247 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
51248 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
51249 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
51250 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
51251 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
51252 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
51253 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
51254 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
51255 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
51256 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
51257 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
51258 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
51259 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
51260 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
51261 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
51262 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
51263 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
51264 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
51265 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
51266 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
51267 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
51268 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
51269 {
51270 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_ANY)));
51271 }
51272 {
51273 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_NONE)));
51274 }
51275 {
51276 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_LEFT)));
51277 }
51278 {
51279 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_MIDDLE)));
51280 }
51281 {
51282 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_RIGHT)));
51283 }
51284 {
51285 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int(static_cast<int >(wxUPDATE_UI_PROCESS_ALL)));
51286 }
51287 {
51288 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int(static_cast<int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
51289 }
51290 {
51291 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::IsBackward)));
51292 }
51293 {
51294 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::IsForward)));
51295 }
51296 {
51297 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::WinChange)));
51298 }
51299 {
51300 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::FromTab)));
51301 }
51302 {
51303 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int(static_cast<int >(wxIDLE_PROCESS_ALL)));
51304 }
51305 {
51306 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int(static_cast<int >(wxIDLE_PROCESS_SPECIFIED)));
51307 }
51308 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
51309 {
51310 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_SUPPRESS)));
51311 }
51312 {
51313 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_EXCEPTION)));
51314 }
51315 {
51316 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_DIALOG)));
51317 }
51318 {
51319 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_LOG)));
51320 }
51321 {
51322 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int(static_cast<int >(wxPRINT_WINDOWS)));
51323 }
51324 {
51325 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int(static_cast<int >(wxPRINT_POSTSCRIPT)));
51326 }
51327 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
51328 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
51329 {
51330 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_NORMAL)));
51331 }
51332 {
51333 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_SMALL)));
51334 }
51335 {
51336 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_MINI)));
51337 }
51338 {
51339 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_LARGE)));
51340 }
51341 {
51342 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_MAX)));
51343 }
51344 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
51345 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
51346 {
51347 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_NONE)));
51348 }
51349 {
51350 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_SPECIFIED)));
51351 }
51352 {
51353 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_ALL)));
51354 }
51355 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
51356 {
51357 PyDict_SetItemString(d,"Left", SWIG_From_int(static_cast<int >(wxLeft)));
51358 }
51359 {
51360 PyDict_SetItemString(d,"Top", SWIG_From_int(static_cast<int >(wxTop)));
51361 }
51362 {
51363 PyDict_SetItemString(d,"Right", SWIG_From_int(static_cast<int >(wxRight)));
51364 }
51365 {
51366 PyDict_SetItemString(d,"Bottom", SWIG_From_int(static_cast<int >(wxBottom)));
51367 }
51368 {
51369 PyDict_SetItemString(d,"Width", SWIG_From_int(static_cast<int >(wxWidth)));
51370 }
51371 {
51372 PyDict_SetItemString(d,"Height", SWIG_From_int(static_cast<int >(wxHeight)));
51373 }
51374 {
51375 PyDict_SetItemString(d,"Centre", SWIG_From_int(static_cast<int >(wxCentre)));
51376 }
51377 {
51378 PyDict_SetItemString(d,"Center", SWIG_From_int(static_cast<int >(wxCenter)));
51379 }
51380 {
51381 PyDict_SetItemString(d,"CentreX", SWIG_From_int(static_cast<int >(wxCentreX)));
51382 }
51383 {
51384 PyDict_SetItemString(d,"CentreY", SWIG_From_int(static_cast<int >(wxCentreY)));
51385 }
51386 {
51387 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int(static_cast<int >(wxUnconstrained)));
51388 }
51389 {
51390 PyDict_SetItemString(d,"AsIs", SWIG_From_int(static_cast<int >(wxAsIs)));
51391 }
51392 {
51393 PyDict_SetItemString(d,"PercentOf", SWIG_From_int(static_cast<int >(wxPercentOf)));
51394 }
51395 {
51396 PyDict_SetItemString(d,"Above", SWIG_From_int(static_cast<int >(wxAbove)));
51397 }
51398 {
51399 PyDict_SetItemString(d,"Below", SWIG_From_int(static_cast<int >(wxBelow)));
51400 }
51401 {
51402 PyDict_SetItemString(d,"LeftOf", SWIG_From_int(static_cast<int >(wxLeftOf)));
51403 }
51404 {
51405 PyDict_SetItemString(d,"RightOf", SWIG_From_int(static_cast<int >(wxRightOf)));
51406 }
51407 {
51408 PyDict_SetItemString(d,"SameAs", SWIG_From_int(static_cast<int >(wxSameAs)));
51409 }
51410 {
51411 PyDict_SetItemString(d,"Absolute", SWIG_From_int(static_cast<int >(wxAbsolute)));
51412 }
51413
51414 // Initialize threading, some globals and such
51415 __wxPyPreStart(d);
51416
51417
51418 // Although these are defined in __version__ they need to be here too so
51419 // that an assert can be done to ensure that the wxPython and the wxWindows
51420 // versions match.
51421 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
51422 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
51423 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
51424
51425 }
51426
wxWidgets (Impactor)