]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
compilation fix for VC8 (see patch 1429985)
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.27
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_VERSION 0x010327
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /***********************************************************************
31 *
32 * This section contains generic SWIG labels for method/variable
33 * declarations/attributes, and other compiler dependent labels.
34 *
35 ************************************************************************/
36
37 /* template workaround for compilers that cannot correctly implement the C++ standard */
38 #ifndef SWIGTEMPLATEDISAMBIGUATOR
39 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
40 # define SWIGTEMPLATEDISAMBIGUATOR template
41 # else
42 # define SWIGTEMPLATEDISAMBIGUATOR
43 # endif
44 #endif
45
46 /* inline attribute */
47 #ifndef SWIGINLINE
48 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
49 # define SWIGINLINE inline
50 # else
51 # define SWIGINLINE
52 # endif
53 #endif
54
55 /* attribute recognised by some compilers to avoid 'unused' warnings */
56 #ifndef SWIGUNUSED
57 # if defined(__GNUC__) || defined(__ICC)
58 # define SWIGUNUSED __attribute__ ((unused))
59 # else
60 # define SWIGUNUSED
61 # endif
62 #endif
63
64 /* internal SWIG method */
65 #ifndef SWIGINTERN
66 # define SWIGINTERN static SWIGUNUSED
67 #endif
68
69 /* internal inline SWIG method */
70 #ifndef SWIGINTERNINLINE
71 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
72 #endif
73
74 /* exporting methods for Windows DLLs */
75 #ifndef SWIGEXPORT
76 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
77 # if defined(STATIC_LINKED)
78 # define SWIGEXPORT
79 # else
80 # define SWIGEXPORT __declspec(dllexport)
81 # endif
82 # else
83 # define SWIGEXPORT
84 # endif
85 #endif
86
87 /* calling conventions for Windows */
88 #ifndef SWIGSTDCALL
89 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
90 # define SWIGSTDCALL __stdcall
91 # else
92 # define SWIGSTDCALL
93 # endif
94 #endif
95
96
97
98 #include <Python.h>
99
100 /***********************************************************************
101 * swigrun.swg
102 *
103 * This file contains generic CAPI SWIG runtime support for pointer
104 * type checking.
105 *
106 ************************************************************************/
107
108 /* This should only be incremented when either the layout of swig_type_info changes,
109 or for whatever reason, the runtime changes incompatibly */
110 #define SWIG_RUNTIME_VERSION "2"
111
112 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
113 #ifdef SWIG_TYPE_TABLE
114 # define SWIG_QUOTE_STRING(x) #x
115 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
116 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
117 #else
118 # define SWIG_TYPE_TABLE_NAME
119 #endif
120
121 /*
122 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
123 creating a static or dynamic library from the swig runtime code.
124 In 99.9% of the cases, swig just needs to declare them as 'static'.
125
126 But only do this if is strictly necessary, ie, if you have problems
127 with your compiler or so.
128 */
129
130 #ifndef SWIGRUNTIME
131 # define SWIGRUNTIME SWIGINTERN
132 #endif
133
134 #ifndef SWIGRUNTIMEINLINE
135 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
136 #endif
137
138 #include <string.h>
139
140 #ifdef __cplusplus
141 extern "C" {
142 #endif
143
144 typedef void *(*swig_converter_func)(void *);
145 typedef struct swig_type_info *(*swig_dycast_func)(void **);
146
147 /* Structure to store inforomation on one type */
148 typedef struct swig_type_info {
149 const char *name; /* mangled name of this type */
150 const char *str; /* human readable name of this type */
151 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
152 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
153 void *clientdata; /* language specific type data */
154 } swig_type_info;
155
156 /* Structure to store a type and conversion function used for casting */
157 typedef struct swig_cast_info {
158 swig_type_info *type; /* pointer to type that is equivalent to this type */
159 swig_converter_func converter; /* function to cast the void pointers */
160 struct swig_cast_info *next; /* pointer to next cast in linked list */
161 struct swig_cast_info *prev; /* pointer to the previous cast */
162 } swig_cast_info;
163
164 /* Structure used to store module information
165 * Each module generates one structure like this, and the runtime collects
166 * all of these structures and stores them in a circularly linked list.*/
167 typedef struct swig_module_info {
168 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
169 size_t size; /* Number of types in this module */
170 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
171 swig_type_info **type_initial; /* Array of initially generated type structures */
172 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
173 void *clientdata; /* Language specific module data */
174 } swig_module_info;
175
176
177 /*
178 Compare two type names skipping the space characters, therefore
179 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
180
181 Return 0 when the two name types are equivalent, as in
182 strncmp, but skipping ' '.
183 */
184 SWIGRUNTIME int
185 SWIG_TypeNameComp(const char *f1, const char *l1,
186 const char *f2, const char *l2) {
187 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
188 while ((*f1 == ' ') && (f1 != l1)) ++f1;
189 while ((*f2 == ' ') && (f2 != l2)) ++f2;
190 if (*f1 != *f2) return (int)(*f1 - *f2);
191 }
192 return (l1 - f1) - (l2 - f2);
193 }
194
195 /*
196 Check type equivalence in a name list like <name1>|<name2>|...
197 Return 0 if not equal, 1 if equal
198 */
199 SWIGRUNTIME int
200 SWIG_TypeEquiv(const char *nb, const char *tb) {
201 int equiv = 0;
202 const char* te = tb + strlen(tb);
203 const char* ne = nb;
204 while (!equiv && *ne) {
205 for (nb = ne; *ne; ++ne) {
206 if (*ne == '|') break;
207 }
208 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
209 if (*ne) ++ne;
210 }
211 return equiv;
212 }
213
214 /*
215 Check type equivalence in a name list like <name1>|<name2>|...
216 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
217 */
218 SWIGRUNTIME int
219 SWIG_TypeCompare(const char *nb, const char *tb) {
220 int equiv = 0;
221 const char* te = tb + strlen(tb);
222 const char* ne = nb;
223 while (!equiv && *ne) {
224 for (nb = ne; *ne; ++ne) {
225 if (*ne == '|') break;
226 }
227 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
228 if (*ne) ++ne;
229 }
230 return equiv;
231 }
232
233
234 /* think of this as a c++ template<> or a scheme macro */
235 #define SWIG_TypeCheck_Template(comparison, ty) \
236 if (ty) { \
237 swig_cast_info *iter = ty->cast; \
238 while (iter) { \
239 if (comparison) { \
240 if (iter == ty->cast) return iter; \
241 /* Move iter to the top of the linked list */ \
242 iter->prev->next = iter->next; \
243 if (iter->next) \
244 iter->next->prev = iter->prev; \
245 iter->next = ty->cast; \
246 iter->prev = 0; \
247 if (ty->cast) ty->cast->prev = iter; \
248 ty->cast = iter; \
249 return iter; \
250 } \
251 iter = iter->next; \
252 } \
253 } \
254 return 0
255
256 /*
257 Check the typename
258 */
259 SWIGRUNTIME swig_cast_info *
260 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
261 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
262 }
263
264 /* Same as previous function, except strcmp is replaced with a pointer comparison */
265 SWIGRUNTIME swig_cast_info *
266 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
267 SWIG_TypeCheck_Template(iter->type == from, into);
268 }
269
270 /*
271 Cast a pointer up an inheritance hierarchy
272 */
273 SWIGRUNTIMEINLINE void *
274 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
275 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
276 }
277
278 /*
279 Dynamic pointer casting. Down an inheritance hierarchy
280 */
281 SWIGRUNTIME swig_type_info *
282 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
283 swig_type_info *lastty = ty;
284 if (!ty || !ty->dcast) return ty;
285 while (ty && (ty->dcast)) {
286 ty = (*ty->dcast)(ptr);
287 if (ty) lastty = ty;
288 }
289 return lastty;
290 }
291
292 /*
293 Return the name associated with this type
294 */
295 SWIGRUNTIMEINLINE const char *
296 SWIG_TypeName(const swig_type_info *ty) {
297 return ty->name;
298 }
299
300 /*
301 Return the pretty name associated with this type,
302 that is an unmangled type name in a form presentable to the user.
303 */
304 SWIGRUNTIME const char *
305 SWIG_TypePrettyName(const swig_type_info *type) {
306 /* The "str" field contains the equivalent pretty names of the
307 type, separated by vertical-bar characters. We choose
308 to print the last name, as it is often (?) the most
309 specific. */
310 if (type->str != NULL) {
311 const char *last_name = type->str;
312 const char *s;
313 for (s = type->str; *s; s++)
314 if (*s == '|') last_name = s+1;
315 return last_name;
316 }
317 else
318 return type->name;
319 }
320
321 /*
322 Set the clientdata field for a type
323 */
324 SWIGRUNTIME void
325 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
326 swig_cast_info *cast = ti->cast;
327 /* if (ti->clientdata == clientdata) return; */
328 ti->clientdata = clientdata;
329
330 while (cast) {
331 if (!cast->converter) {
332 swig_type_info *tc = cast->type;
333 if (!tc->clientdata) {
334 SWIG_TypeClientData(tc, clientdata);
335 }
336 }
337 cast = cast->next;
338 }
339 }
340
341 /*
342 Search for a swig_type_info structure only by mangled name
343 Search is a O(log #types)
344
345 We start searching at module start, and finish searching when start == end.
346 Note: if start == end at the beginning of the function, we go all the way around
347 the circular list.
348 */
349 SWIGRUNTIME swig_type_info *
350 SWIG_MangledTypeQueryModule(swig_module_info *start,
351 swig_module_info *end,
352 const char *name) {
353 swig_module_info *iter = start;
354 do {
355 if (iter->size) {
356 register size_t l = 0;
357 register size_t r = iter->size - 1;
358 do {
359 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
360 register size_t i = (l + r) >> 1;
361 const char *iname = iter->types[i]->name;
362 if (iname) {
363 register int compare = strcmp(name, iname);
364 if (compare == 0) {
365 return iter->types[i];
366 } else if (compare < 0) {
367 if (i) {
368 r = i - 1;
369 } else {
370 break;
371 }
372 } else if (compare > 0) {
373 l = i + 1;
374 }
375 } else {
376 break; /* should never happen */
377 }
378 } while (l <= r);
379 }
380 iter = iter->next;
381 } while (iter != end);
382 return 0;
383 }
384
385 /*
386 Search for a swig_type_info structure for either a mangled name or a human readable name.
387 It first searches the mangled names of the types, which is a O(log #types)
388 If a type is not found it then searches the human readable names, which is O(#types).
389
390 We start searching at module start, and finish searching when start == end.
391 Note: if start == end at the beginning of the function, we go all the way around
392 the circular list.
393 */
394 SWIGRUNTIME swig_type_info *
395 SWIG_TypeQueryModule(swig_module_info *start,
396 swig_module_info *end,
397 const char *name) {
398 /* STEP 1: Search the name field using binary search */
399 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
400 if (ret) {
401 return ret;
402 } else {
403 /* STEP 2: If the type hasn't been found, do a complete search
404 of the str field (the human readable name) */
405 swig_module_info *iter = start;
406 do {
407 register size_t i = 0;
408 for (; i < iter->size; ++i) {
409 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
410 return iter->types[i];
411 }
412 iter = iter->next;
413 } while (iter != end);
414 }
415
416 /* neither found a match */
417 return 0;
418 }
419
420
421 /*
422 Pack binary data into a string
423 */
424 SWIGRUNTIME char *
425 SWIG_PackData(char *c, void *ptr, size_t sz) {
426 static const char hex[17] = "0123456789abcdef";
427 register const unsigned char *u = (unsigned char *) ptr;
428 register const unsigned char *eu = u + sz;
429 for (; u != eu; ++u) {
430 register unsigned char uu = *u;
431 *(c++) = hex[(uu & 0xf0) >> 4];
432 *(c++) = hex[uu & 0xf];
433 }
434 return c;
435 }
436
437 /*
438 Unpack binary data from a string
439 */
440 SWIGRUNTIME const char *
441 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
442 register unsigned char *u = (unsigned char *) ptr;
443 register const unsigned char *eu = u + sz;
444 for (; u != eu; ++u) {
445 register char d = *(c++);
446 register unsigned char uu = 0;
447 if ((d >= '0') && (d <= '9'))
448 uu = ((d - '0') << 4);
449 else if ((d >= 'a') && (d <= 'f'))
450 uu = ((d - ('a'-10)) << 4);
451 else
452 return (char *) 0;
453 d = *(c++);
454 if ((d >= '0') && (d <= '9'))
455 uu |= (d - '0');
456 else if ((d >= 'a') && (d <= 'f'))
457 uu |= (d - ('a'-10));
458 else
459 return (char *) 0;
460 *u = uu;
461 }
462 return c;
463 }
464
465 /*
466 Pack 'void *' into a string buffer.
467 */
468 SWIGRUNTIME char *
469 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
470 char *r = buff;
471 if ((2*sizeof(void *) + 2) > bsz) return 0;
472 *(r++) = '_';
473 r = SWIG_PackData(r,&ptr,sizeof(void *));
474 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
475 strcpy(r,name);
476 return buff;
477 }
478
479 SWIGRUNTIME const char *
480 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
481 if (*c != '_') {
482 if (strcmp(c,"NULL") == 0) {
483 *ptr = (void *) 0;
484 return name;
485 } else {
486 return 0;
487 }
488 }
489 return SWIG_UnpackData(++c,ptr,sizeof(void *));
490 }
491
492 SWIGRUNTIME char *
493 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
494 char *r = buff;
495 size_t lname = (name ? strlen(name) : 0);
496 if ((2*sz + 2 + lname) > bsz) return 0;
497 *(r++) = '_';
498 r = SWIG_PackData(r,ptr,sz);
499 if (lname) {
500 strncpy(r,name,lname+1);
501 } else {
502 *r = 0;
503 }
504 return buff;
505 }
506
507 SWIGRUNTIME const char *
508 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
509 if (*c != '_') {
510 if (strcmp(c,"NULL") == 0) {
511 memset(ptr,0,sz);
512 return name;
513 } else {
514 return 0;
515 }
516 }
517 return SWIG_UnpackData(++c,ptr,sz);
518 }
519
520 #ifdef __cplusplus
521 }
522 #endif
523
524 /* -----------------------------------------------------------------------------
525 * SWIG API. Portion that goes into the runtime
526 * ----------------------------------------------------------------------------- */
527
528 #ifdef __cplusplus
529 extern "C" {
530 #endif
531
532 /* -----------------------------------------------------------------------------
533 * for internal method declarations
534 * ----------------------------------------------------------------------------- */
535
536 #ifndef SWIGINTERN
537 # define SWIGINTERN static SWIGUNUSED
538 #endif
539
540 #ifndef SWIGINTERNINLINE
541 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
542 #endif
543
544 /*
545 Exception handling in wrappers
546 */
547 #define SWIG_fail goto fail
548 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
549 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
550 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
551 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
552 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
553
554 /*
555 Contract support
556 */
557 #define SWIG_contract_assert(expr, msg) \
558 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
559
560 /* -----------------------------------------------------------------------------
561 * Constant declarations
562 * ----------------------------------------------------------------------------- */
563
564 /* Constant Types */
565 #define SWIG_PY_INT 1
566 #define SWIG_PY_FLOAT 2
567 #define SWIG_PY_STRING 3
568 #define SWIG_PY_POINTER 4
569 #define SWIG_PY_BINARY 5
570
571 /* Constant information structure */
572 typedef struct swig_const_info {
573 int type;
574 char *name;
575 long lvalue;
576 double dvalue;
577 void *pvalue;
578 swig_type_info **ptype;
579 } swig_const_info;
580
581
582 /* -----------------------------------------------------------------------------
583 * Alloc. memory flags
584 * ----------------------------------------------------------------------------- */
585 #define SWIG_OLDOBJ 1
586 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
587 #define SWIG_PYSTR SWIG_NEWOBJ + 1
588
589 #ifdef __cplusplus
590 }
591 #endif
592
593
594 /***********************************************************************
595 * pyrun.swg
596 *
597 * This file contains the runtime support for Python modules
598 * and includes code for managing global variables and pointer
599 * type checking.
600 *
601 * Author : David Beazley (beazley@cs.uchicago.edu)
602 ************************************************************************/
603
604 /* Common SWIG API */
605 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
606 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
607 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
608
609
610 /* Python-specific SWIG API */
611 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
612 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
613
614 /* Runtime API */
615 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
616 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
617
618 /* -----------------------------------------------------------------------------
619 * Pointer declarations
620 * ----------------------------------------------------------------------------- */
621 /*
622 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
623 C/C++ pointers in the python side. Very useful for debugging, but
624 not always safe.
625 */
626 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
627 # define SWIG_COBJECT_TYPES
628 #endif
629
630 /* Flags for pointer conversion */
631 #define SWIG_POINTER_EXCEPTION 0x1
632 #define SWIG_POINTER_DISOWN 0x2
633
634
635 /* Add PyOS_snprintf for old Pythons */
636 #if PY_VERSION_HEX < 0x02020000
637 #define PyOS_snprintf snprintf
638 #endif
639
640 #ifdef __cplusplus
641 extern "C" {
642 #endif
643
644 /* -----------------------------------------------------------------------------
645 * Create a new pointer string
646 * ----------------------------------------------------------------------------- */
647 #ifndef SWIG_BUFFER_SIZE
648 #define SWIG_BUFFER_SIZE 1024
649 #endif
650
651 /* A crude PyString_FromFormat implementation for old Pythons */
652 #if PY_VERSION_HEX < 0x02020000
653 static PyObject *
654 PyString_FromFormat(const char *fmt, ...) {
655 va_list ap;
656 char buf[SWIG_BUFFER_SIZE * 2];
657 int res;
658 va_start(ap, fmt);
659 res = vsnprintf(buf, sizeof(buf), fmt, ap);
660 va_end(ap);
661 return (res < 0 || res >= sizeof(buf)) ? 0 : PyString_FromString(buf);
662 }
663 #endif
664
665 #if PY_VERSION_HEX < 0x01060000
666 #define PyObject_Del(op) PyMem_DEL((op))
667 #endif
668
669 #if defined(SWIG_COBJECT_TYPES)
670 #if !defined(SWIG_COBJECT_PYTHON)
671 /* -----------------------------------------------------------------------------
672 * Implements a simple Swig Object type, and use it instead of PyCObject
673 * ----------------------------------------------------------------------------- */
674
675 typedef struct {
676 PyObject_HEAD
677 void *ptr;
678 const char *desc;
679 } PySwigObject;
680
681 /* Declarations for objects of type PySwigObject */
682
683 SWIGRUNTIME int
684 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
685 {
686 char result[SWIG_BUFFER_SIZE];
687 flags = flags;
688 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
689 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
690 return 0;
691 } else {
692 return 1;
693 }
694 }
695
696 SWIGRUNTIME PyObject *
697 PySwigObject_repr(PySwigObject *v)
698 {
699 char result[SWIG_BUFFER_SIZE];
700 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
701 PyString_FromFormat("<Swig Object at %s>", result) : 0;
702 }
703
704 SWIGRUNTIME PyObject *
705 PySwigObject_str(PySwigObject *v)
706 {
707 char result[SWIG_BUFFER_SIZE];
708 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
709 PyString_FromString(result) : 0;
710 }
711
712 SWIGRUNTIME PyObject *
713 PySwigObject_long(PySwigObject *v)
714 {
715 return PyLong_FromVoidPtr(v->ptr);
716 }
717
718 SWIGRUNTIME PyObject *
719 PySwigObject_format(const char* fmt, PySwigObject *v)
720 {
721 PyObject *res = NULL;
722 PyObject *args = PyTuple_New(1);
723 if (args && (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0)) {
724 PyObject *ofmt = PyString_FromString(fmt);
725 if (ofmt) {
726 res = PyString_Format(ofmt,args);
727 Py_DECREF(ofmt);
728 }
729 Py_DECREF(args);
730 }
731 return res;
732 }
733
734 SWIGRUNTIME PyObject *
735 PySwigObject_oct(PySwigObject *v)
736 {
737 return PySwigObject_format("%o",v);
738 }
739
740 SWIGRUNTIME PyObject *
741 PySwigObject_hex(PySwigObject *v)
742 {
743 return PySwigObject_format("%x",v);
744 }
745
746 SWIGRUNTIME int
747 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
748 {
749 int c = strcmp(v->desc, w->desc);
750 if (c) {
751 return (c > 0) ? 1 : -1;
752 } else {
753 void *i = v->ptr;
754 void *j = w->ptr;
755 return (i < j) ? -1 : ((i > j) ? 1 : 0);
756 }
757 }
758
759 SWIGRUNTIME void
760 PySwigObject_dealloc(PySwigObject *self)
761 {
762 PyObject_Del(self);
763 }
764
765 SWIGRUNTIME PyTypeObject*
766 PySwigObject_type(void) {
767 static char pyswigobject_type__doc__[] =
768 "Swig object carries a C/C++ instance pointer";
769
770 static PyNumberMethods PySwigObject_as_number = {
771 (binaryfunc)0, /*nb_add*/
772 (binaryfunc)0, /*nb_subtract*/
773 (binaryfunc)0, /*nb_multiply*/
774 (binaryfunc)0, /*nb_divide*/
775 (binaryfunc)0, /*nb_remainder*/
776 (binaryfunc)0, /*nb_divmod*/
777 (ternaryfunc)0,/*nb_power*/
778 (unaryfunc)0, /*nb_negative*/
779 (unaryfunc)0, /*nb_positive*/
780 (unaryfunc)0, /*nb_absolute*/
781 (inquiry)0, /*nb_nonzero*/
782 0, /*nb_invert*/
783 0, /*nb_lshift*/
784 0, /*nb_rshift*/
785 0, /*nb_and*/
786 0, /*nb_xor*/
787 0, /*nb_or*/
788 (coercion)0, /*nb_coerce*/
789 (unaryfunc)PySwigObject_long, /*nb_int*/
790 (unaryfunc)PySwigObject_long, /*nb_long*/
791 (unaryfunc)0, /*nb_float*/
792 (unaryfunc)PySwigObject_oct, /*nb_oct*/
793 (unaryfunc)PySwigObject_hex, /*nb_hex*/
794 #if PY_VERSION_HEX >= 0x02020000
795 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
796 #elif PY_VERSION_HEX >= 0x02000000
797 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
798 #endif
799 };
800
801 static PyTypeObject pyswigobject_type
802 #if !defined(__cplusplus)
803 ;
804 static int type_init = 0;
805 if (!type_init) {
806 PyTypeObject tmp
807 #endif
808 = {
809 PyObject_HEAD_INIT(&PyType_Type)
810 0, /*ob_size*/
811 (char *)"PySwigObject", /*tp_name*/
812 sizeof(PySwigObject), /*tp_basicsize*/
813 0, /*tp_itemsize*/
814 /* methods */
815 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
816 (printfunc)PySwigObject_print, /*tp_print*/
817 (getattrfunc)0, /*tp_getattr*/
818 (setattrfunc)0, /*tp_setattr*/
819 (cmpfunc)PySwigObject_compare, /*tp_compare*/
820 (reprfunc)PySwigObject_repr, /*tp_repr*/
821 &PySwigObject_as_number, /*tp_as_number*/
822 0, /*tp_as_sequence*/
823 0, /*tp_as_mapping*/
824 (hashfunc)0, /*tp_hash*/
825 (ternaryfunc)0, /*tp_call*/
826 (reprfunc)PySwigObject_str, /*tp_str*/
827 /* Space for future expansion */
828 0,0,0,0,
829 pyswigobject_type__doc__, /* Documentation string */
830 #if PY_VERSION_HEX >= 0x02000000
831 0, /* tp_traverse */
832 0, /* tp_clear */
833 #endif
834 #if PY_VERSION_HEX >= 0x02010000
835 0, /* tp_richcompare */
836 0, /* tp_weaklistoffset */
837 #endif
838 #if PY_VERSION_HEX >= 0x02020000
839 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
840 #endif
841 #if PY_VERSION_HEX >= 0x02030000
842 0, /* tp_del */
843 #endif
844 #ifdef COUNT_ALLOCS
845 0,0,0,0 /* tp_alloc -> tp_next */
846 #endif
847 };
848 #if !defined(__cplusplus)
849 pyswigobject_type = tmp;
850 type_init = 1;
851 }
852 #endif
853 return &pyswigobject_type;
854 }
855
856 SWIGRUNTIME PyObject *
857 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
858 {
859 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_type());
860 if (self) {
861 self->ptr = ptr;
862 self->desc = desc;
863 }
864 return (PyObject *)self;
865 }
866
867 SWIGRUNTIMEINLINE void *
868 PySwigObject_AsVoidPtr(PyObject *self)
869 {
870 return ((PySwigObject *)self)->ptr;
871 }
872
873 SWIGRUNTIMEINLINE const char *
874 PySwigObject_GetDesc(PyObject *self)
875 {
876 return ((PySwigObject *)self)->desc;
877 }
878
879 SWIGRUNTIMEINLINE int
880 PySwigObject_Check(PyObject *op) {
881 return ((op)->ob_type == PySwigObject_type())
882 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
883 }
884
885 /* -----------------------------------------------------------------------------
886 * Implements a simple Swig Packed type, and use it instead of string
887 * ----------------------------------------------------------------------------- */
888
889 typedef struct {
890 PyObject_HEAD
891 void *pack;
892 const char *desc;
893 size_t size;
894 } PySwigPacked;
895
896 SWIGRUNTIME int
897 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
898 {
899 char result[SWIG_BUFFER_SIZE];
900 flags = flags;
901 fputs("<Swig Packed ", fp);
902 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
903 fputs("at ", fp);
904 fputs(result, fp);
905 }
906 fputs(v->desc,fp);
907 fputs(">", fp);
908 return 0;
909 }
910
911 SWIGRUNTIME PyObject *
912 PySwigPacked_repr(PySwigPacked *v)
913 {
914 char result[SWIG_BUFFER_SIZE];
915 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
916 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
917 } else {
918 return PyString_FromFormat("<Swig Packed %s>", v->desc);
919 }
920 }
921
922 SWIGRUNTIME PyObject *
923 PySwigPacked_str(PySwigPacked *v)
924 {
925 char result[SWIG_BUFFER_SIZE];
926 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
927 return PyString_FromFormat("%s%s", result, v->desc);
928 } else {
929 return PyString_FromString(v->desc);
930 }
931 }
932
933 SWIGRUNTIME int
934 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
935 {
936 int c = strcmp(v->desc, w->desc);
937 if (c) {
938 return (c > 0) ? 1 : -1;
939 } else {
940 size_t i = v->size;
941 size_t j = w->size;
942 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
943 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
944 }
945 }
946
947 SWIGRUNTIME void
948 PySwigPacked_dealloc(PySwigPacked *self)
949 {
950 free(self->pack);
951 PyObject_Del(self);
952 }
953
954 SWIGRUNTIME PyTypeObject*
955 PySwigPacked_type(void) {
956 static char pyswigpacked_type__doc__[] =
957 "Swig object carries a C/C++ instance pointer";
958 static PyTypeObject pyswigpacked_type
959 #if !defined(__cplusplus)
960 ;
961 static int type_init = 0;
962 if (!type_init) {
963 PyTypeObject tmp
964 #endif
965 = {
966 PyObject_HEAD_INIT(&PyType_Type)
967 0, /*ob_size*/
968 (char *)"PySwigPacked", /*tp_name*/
969 sizeof(PySwigPacked), /*tp_basicsize*/
970 0, /*tp_itemsize*/
971 /* methods */
972 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
973 (printfunc)PySwigPacked_print, /*tp_print*/
974 (getattrfunc)0, /*tp_getattr*/
975 (setattrfunc)0, /*tp_setattr*/
976 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
977 (reprfunc)PySwigPacked_repr, /*tp_repr*/
978 0, /*tp_as_number*/
979 0, /*tp_as_sequence*/
980 0, /*tp_as_mapping*/
981 (hashfunc)0, /*tp_hash*/
982 (ternaryfunc)0, /*tp_call*/
983 (reprfunc)PySwigPacked_str, /*tp_str*/
984 /* Space for future expansion */
985 0,0,0,0,
986 pyswigpacked_type__doc__, /* Documentation string */
987 #if PY_VERSION_HEX >= 0x02000000
988 0, /* tp_traverse */
989 0, /* tp_clear */
990 #endif
991 #if PY_VERSION_HEX >= 0x02010000
992 0, /* tp_richcompare */
993 0, /* tp_weaklistoffset */
994 #endif
995 #if PY_VERSION_HEX >= 0x02020000
996 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
997 #endif
998 #if PY_VERSION_HEX >= 0x02030000
999 0, /* tp_del */
1000 #endif
1001 #ifdef COUNT_ALLOCS
1002 0,0,0,0 /* tp_alloc -> tp_next */
1003 #endif
1004 };
1005 #if !defined(__cplusplus)
1006 pyswigpacked_type = tmp;
1007 type_init = 1;
1008 }
1009 #endif
1010 return &pyswigpacked_type;
1011 }
1012
1013 SWIGRUNTIME PyObject *
1014 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
1015 {
1016 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1017 if (self == NULL) {
1018 return NULL;
1019 } else {
1020 void *pack = malloc(size);
1021 if (pack) {
1022 memcpy(pack, ptr, size);
1023 self->pack = pack;
1024 self->desc = desc;
1025 self->size = size;
1026 return (PyObject *) self;
1027 }
1028 return NULL;
1029 }
1030 }
1031
1032 SWIGRUNTIMEINLINE const char *
1033 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1034 {
1035 PySwigPacked *self = (PySwigPacked *)obj;
1036 if (self->size != size) return 0;
1037 memcpy(ptr, self->pack, size);
1038 return self->desc;
1039 }
1040
1041 SWIGRUNTIMEINLINE const char *
1042 PySwigPacked_GetDesc(PyObject *self)
1043 {
1044 return ((PySwigPacked *)self)->desc;
1045 }
1046
1047 SWIGRUNTIMEINLINE int
1048 PySwigPacked_Check(PyObject *op) {
1049 return ((op)->ob_type == PySwigPacked_type())
1050 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1051 }
1052
1053 #else
1054 /* -----------------------------------------------------------------------------
1055 * Use the old Python PyCObject instead of PySwigObject
1056 * ----------------------------------------------------------------------------- */
1057
1058 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1059 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1060 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1061 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1062
1063 #endif
1064
1065 #endif
1066
1067 /* -----------------------------------------------------------------------------
1068 * errors manipulation
1069 * ----------------------------------------------------------------------------- */
1070
1071 SWIGRUNTIME void
1072 SWIG_Python_TypeError(const char *type, PyObject *obj)
1073 {
1074 if (type) {
1075 #if defined(SWIG_COBJECT_TYPES)
1076 if (obj && PySwigObject_Check(obj)) {
1077 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1078 if (otype) {
1079 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1080 type, otype);
1081 return;
1082 }
1083 } else
1084 #endif
1085 {
1086 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1087 if (otype) {
1088 PyObject *str = PyObject_Str(obj);
1089 const char *cstr = str ? PyString_AsString(str) : 0;
1090 if (cstr) {
1091 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1092 type, otype, cstr);
1093 } else {
1094 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1095 type, otype);
1096 }
1097 Py_XDECREF(str);
1098 return;
1099 }
1100 }
1101 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1102 } else {
1103 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1104 }
1105 }
1106
1107 SWIGRUNTIMEINLINE void
1108 SWIG_Python_NullRef(const char *type)
1109 {
1110 if (type) {
1111 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1112 } else {
1113 PyErr_Format(PyExc_TypeError, "null reference was received");
1114 }
1115 }
1116
1117 SWIGRUNTIME int
1118 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1119 {
1120 if (PyErr_Occurred()) {
1121 PyObject *type = 0;
1122 PyObject *value = 0;
1123 PyObject *traceback = 0;
1124 PyErr_Fetch(&type, &value, &traceback);
1125 if (value) {
1126 PyObject *old_str = PyObject_Str(value);
1127 Py_XINCREF(type);
1128 PyErr_Clear();
1129 if (infront) {
1130 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1131 } else {
1132 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1133 }
1134 Py_DECREF(old_str);
1135 }
1136 return 1;
1137 } else {
1138 return 0;
1139 }
1140 }
1141
1142 SWIGRUNTIME int
1143 SWIG_Python_ArgFail(int argnum)
1144 {
1145 if (PyErr_Occurred()) {
1146 /* add information about failing argument */
1147 char mesg[256];
1148 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
1149 return SWIG_Python_AddErrMesg(mesg, 1);
1150 } else {
1151 return 0;
1152 }
1153 }
1154
1155
1156 /* -----------------------------------------------------------------------------
1157 * pointers/data manipulation
1158 * ----------------------------------------------------------------------------- */
1159
1160 /* Convert a pointer value */
1161 SWIGRUNTIME int
1162 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1163 swig_cast_info *tc;
1164 const char *c = 0;
1165 static PyObject *SWIG_this = 0;
1166 int newref = 0;
1167 PyObject *pyobj = 0;
1168 void *vptr;
1169
1170 if (!obj) return 0;
1171 if (obj == Py_None) {
1172 *ptr = 0;
1173 return 0;
1174 }
1175
1176 #ifdef SWIG_COBJECT_TYPES
1177 if (!(PySwigObject_Check(obj))) {
1178 if (!SWIG_this)
1179 SWIG_this = PyString_FromString("this");
1180 pyobj = obj;
1181 obj = PyObject_GetAttr(obj,SWIG_this);
1182 newref = 1;
1183 if (!obj) goto type_error;
1184 if (!PySwigObject_Check(obj)) {
1185 Py_DECREF(obj);
1186 goto type_error;
1187 }
1188 }
1189 vptr = PySwigObject_AsVoidPtr(obj);
1190 c = (const char *) PySwigObject_GetDesc(obj);
1191 if (newref) { Py_DECREF(obj); }
1192 goto type_check;
1193 #else
1194 if (!(PyString_Check(obj))) {
1195 if (!SWIG_this)
1196 SWIG_this = PyString_FromString("this");
1197 pyobj = obj;
1198 obj = PyObject_GetAttr(obj,SWIG_this);
1199 newref = 1;
1200 if (!obj) goto type_error;
1201 if (!PyString_Check(obj)) {
1202 Py_DECREF(obj);
1203 goto type_error;
1204 }
1205 }
1206 c = PyString_AsString(obj);
1207 /* Pointer values must start with leading underscore */
1208 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1209 if (newref) { Py_DECREF(obj); }
1210 if (!c) goto type_error;
1211 #endif
1212
1213 type_check:
1214 if (ty) {
1215 tc = SWIG_TypeCheck(c,ty);
1216 if (!tc) goto type_error;
1217 *ptr = SWIG_TypeCast(tc,vptr);
1218 } else {
1219 *ptr = vptr;
1220 }
1221 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1222 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1223 }
1224 return 0;
1225
1226 type_error:
1227 PyErr_Clear();
1228 if (pyobj && !obj) {
1229 obj = pyobj;
1230 if (PyCFunction_Check(obj)) {
1231 /* here we get the method pointer for callbacks */
1232 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1233 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1234 if (c) {
1235 c = ty ? SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name) : 0;
1236 if (!c) goto type_error;
1237 goto type_check;
1238 }
1239 }
1240 }
1241 if (flags & SWIG_POINTER_EXCEPTION) {
1242 if (ty) {
1243 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1244 } else {
1245 SWIG_Python_TypeError("C/C++ pointer", obj);
1246 }
1247 }
1248 return -1;
1249 }
1250
1251 /* Convert a pointer value, signal an exception on a type mismatch */
1252 SWIGRUNTIME void *
1253 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1254 void *result;
1255 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1256 PyErr_Clear();
1257 if (flags & SWIG_POINTER_EXCEPTION) {
1258 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1259 SWIG_Python_ArgFail(argnum);
1260 }
1261 }
1262 return result;
1263 }
1264
1265 /* Convert a packed value value */
1266 SWIGRUNTIME int
1267 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1268 swig_cast_info *tc;
1269 const char *c = 0;
1270
1271 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1272 c = PySwigPacked_UnpackData(obj, ptr, sz);
1273 #else
1274 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1275 c = PyString_AsString(obj);
1276 /* Pointer values must start with leading underscore */
1277 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1278 #endif
1279 if (!c) goto type_error;
1280 if (ty) {
1281 tc = SWIG_TypeCheck(c,ty);
1282 if (!tc) goto type_error;
1283 }
1284 return 0;
1285
1286 type_error:
1287 PyErr_Clear();
1288 if (flags & SWIG_POINTER_EXCEPTION) {
1289 if (ty) {
1290 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1291 } else {
1292 SWIG_Python_TypeError("C/C++ packed data", obj);
1293 }
1294 }
1295 return -1;
1296 }
1297
1298 /* Create a new array object */
1299 SWIGRUNTIME PyObject *
1300 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1301 PyObject *robj = 0;
1302 if (!type) {
1303 if (!PyErr_Occurred()) {
1304 PyErr_Format(PyExc_TypeError, "Swig: null type passed to NewPointerObj");
1305 }
1306 return robj;
1307 }
1308 if (!ptr) {
1309 Py_INCREF(Py_None);
1310 return Py_None;
1311 }
1312 #ifdef SWIG_COBJECT_TYPES
1313 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1314 #else
1315 {
1316 char result[SWIG_BUFFER_SIZE];
1317 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1318 PyString_FromString(result) : 0;
1319 }
1320 #endif
1321 if (!robj || (robj == Py_None)) return robj;
1322 if (type->clientdata) {
1323 PyObject *inst;
1324 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1325 Py_DECREF(robj);
1326 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1327 Py_DECREF(args);
1328 if (inst) {
1329 if (own) {
1330 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1331 }
1332 robj = inst;
1333 }
1334 }
1335 return robj;
1336 }
1337
1338 SWIGRUNTIME PyObject *
1339 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1340 PyObject *robj = 0;
1341 if (!ptr) {
1342 Py_INCREF(Py_None);
1343 return Py_None;
1344 }
1345 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1346 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1347 #else
1348 {
1349 char result[SWIG_BUFFER_SIZE];
1350 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1351 PyString_FromString(result) : 0;
1352 }
1353 #endif
1354 return robj;
1355 }
1356
1357 /* -----------------------------------------------------------------------------*
1358 * Get type list
1359 * -----------------------------------------------------------------------------*/
1360
1361 #ifdef SWIG_LINK_RUNTIME
1362 void *SWIG_ReturnGlobalTypeList(void *);
1363 #endif
1364
1365 SWIGRUNTIME swig_module_info *
1366 SWIG_Python_GetModule(void) {
1367 static void *type_pointer = (void *)0;
1368 /* first check if module already created */
1369 if (!type_pointer) {
1370 #ifdef SWIG_LINK_RUNTIME
1371 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1372 #else
1373 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1374 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1375 if (PyErr_Occurred()) {
1376 PyErr_Clear();
1377 type_pointer = (void *)0;
1378 }
1379 #endif
1380 }
1381 return (swig_module_info *) type_pointer;
1382 }
1383
1384 #if PY_MAJOR_VERSION < 2
1385 /* PyModule_AddObject function was introduced in Python 2.0. The following function
1386 is copied out of Python/modsupport.c in python version 2.3.4 */
1387 SWIGINTERN int
1388 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
1389 {
1390 PyObject *dict;
1391 if (!PyModule_Check(m)) {
1392 PyErr_SetString(PyExc_TypeError,
1393 "PyModule_AddObject() needs module as first arg");
1394 return -1;
1395 }
1396 if (!o) {
1397 PyErr_SetString(PyExc_TypeError,
1398 "PyModule_AddObject() needs non-NULL value");
1399 return -1;
1400 }
1401
1402 dict = PyModule_GetDict(m);
1403 if (dict == NULL) {
1404 /* Internal error -- modules must have a dict! */
1405 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
1406 PyModule_GetName(m));
1407 return -1;
1408 }
1409 if (PyDict_SetItemString(dict, name, o))
1410 return -1;
1411 Py_DECREF(o);
1412 return 0;
1413 }
1414 #endif
1415
1416 SWIGRUNTIME void
1417 SWIG_Python_SetModule(swig_module_info *swig_module) {
1418 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
1419
1420 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1421 swig_empty_runtime_method_table);
1422 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, NULL);
1423 if (pointer && module) {
1424 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
1425 }
1426 }
1427
1428 #ifdef __cplusplus
1429 }
1430 #endif
1431
1432
1433 /* -------- TYPES TABLE (BEGIN) -------- */
1434
1435 #define SWIGTYPE_p_buffer swig_types[0]
1436 #define SWIGTYPE_p_char swig_types[1]
1437 #define SWIGTYPE_p_form_ops_t swig_types[2]
1438 #define SWIGTYPE_p_int swig_types[3]
1439 #define SWIGTYPE_p_long swig_types[4]
1440 #define SWIGTYPE_p_unsigned_char swig_types[5]
1441 #define SWIGTYPE_p_unsigned_int swig_types[6]
1442 #define SWIGTYPE_p_unsigned_long swig_types[7]
1443 #define SWIGTYPE_p_wxANIHandler swig_types[8]
1444 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
1445 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
1446 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
1447 #define SWIGTYPE_p_wxAppTraits swig_types[12]
1448 #define SWIGTYPE_p_wxArrayString swig_types[13]
1449 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
1450 #define SWIGTYPE_p_wxBitmap swig_types[15]
1451 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
1452 #define SWIGTYPE_p_wxButton swig_types[17]
1453 #define SWIGTYPE_p_wxCURHandler swig_types[18]
1454 #define SWIGTYPE_p_wxCaret swig_types[19]
1455 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
1456 #define SWIGTYPE_p_wxCloseEvent swig_types[21]
1457 #define SWIGTYPE_p_wxColour swig_types[22]
1458 #define SWIGTYPE_p_wxCommandEvent swig_types[23]
1459 #define SWIGTYPE_p_wxContextMenuEvent swig_types[24]
1460 #define SWIGTYPE_p_wxControl swig_types[25]
1461 #define SWIGTYPE_p_wxControlWithItems swig_types[26]
1462 #define SWIGTYPE_p_wxCursor swig_types[27]
1463 #define SWIGTYPE_p_wxDC swig_types[28]
1464 #define SWIGTYPE_p_wxDateEvent swig_types[29]
1465 #define SWIGTYPE_p_wxDateTime swig_types[30]
1466 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
1467 #define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
1468 #define SWIGTYPE_p_wxDuplexMode swig_types[33]
1469 #define SWIGTYPE_p_wxEraseEvent swig_types[34]
1470 #define SWIGTYPE_p_wxEvent swig_types[35]
1471 #define SWIGTYPE_p_wxEventLoop swig_types[36]
1472 #define SWIGTYPE_p_wxEventLoopActivator swig_types[37]
1473 #define SWIGTYPE_p_wxEvtHandler swig_types[38]
1474 #define SWIGTYPE_p_wxFSFile swig_types[39]
1475 #define SWIGTYPE_p_wxFileSystem swig_types[40]
1476 #define SWIGTYPE_p_wxFileSystemHandler swig_types[41]
1477 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
1478 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
1479 #define SWIGTYPE_p_wxFont swig_types[44]
1480 #define SWIGTYPE_p_wxFrame swig_types[45]
1481 #define SWIGTYPE_p_wxGBPosition swig_types[46]
1482 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
1483 #define SWIGTYPE_p_wxGBSpan swig_types[48]
1484 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
1485 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
1486 #define SWIGTYPE_p_wxGridSizer swig_types[51]
1487 #define SWIGTYPE_p_wxICOHandler swig_types[52]
1488 #define SWIGTYPE_p_wxIconizeEvent swig_types[53]
1489 #define SWIGTYPE_p_wxIdleEvent swig_types[54]
1490 #define SWIGTYPE_p_wxImage swig_types[55]
1491 #define SWIGTYPE_p_wxImageHandler swig_types[56]
1492 #define SWIGTYPE_p_wxImageHistogram swig_types[57]
1493 #define SWIGTYPE_p_wxImage_HSVValue swig_types[58]
1494 #define SWIGTYPE_p_wxImage_RGBValue swig_types[59]
1495 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[60]
1496 #define SWIGTYPE_p_wxInitDialogEvent swig_types[61]
1497 #define SWIGTYPE_p_wxInputStream swig_types[62]
1498 #define SWIGTYPE_p_wxInternetFSHandler swig_types[63]
1499 #define SWIGTYPE_p_wxItemContainer swig_types[64]
1500 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1501 #define SWIGTYPE_p_wxKeyEvent swig_types[66]
1502 #define SWIGTYPE_p_wxLayoutConstraints swig_types[67]
1503 #define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
1504 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
1505 #define SWIGTYPE_p_wxMenu swig_types[70]
1506 #define SWIGTYPE_p_wxMenuBar swig_types[71]
1507 #define SWIGTYPE_p_wxMenuBarBase swig_types[72]
1508 #define SWIGTYPE_p_wxMenuEvent swig_types[73]
1509 #define SWIGTYPE_p_wxMenuItem swig_types[74]
1510 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]
1511 #define SWIGTYPE_p_wxMouseEvent swig_types[76]
1512 #define SWIGTYPE_p_wxMoveEvent swig_types[77]
1513 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[78]
1514 #define SWIGTYPE_p_wxNcPaintEvent swig_types[79]
1515 #define SWIGTYPE_p_wxNotifyEvent swig_types[80]
1516 #define SWIGTYPE_p_wxObject swig_types[81]
1517 #define SWIGTYPE_p_wxOutputStream swig_types[82]
1518 #define SWIGTYPE_p_wxPCXHandler swig_types[83]
1519 #define SWIGTYPE_p_wxPNGHandler swig_types[84]
1520 #define SWIGTYPE_p_wxPNMHandler swig_types[85]
1521 #define SWIGTYPE_p_wxPaintEvent swig_types[86]
1522 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[87]
1523 #define SWIGTYPE_p_wxPaperSize swig_types[88]
1524 #define SWIGTYPE_p_wxPoint swig_types[89]
1525 #define SWIGTYPE_p_wxPoint2D swig_types[90]
1526 #define SWIGTYPE_p_wxPropagateOnce swig_types[91]
1527 #define SWIGTYPE_p_wxPropagationDisabler swig_types[92]
1528 #define SWIGTYPE_p_wxPyApp swig_types[93]
1529 #define SWIGTYPE_p_wxPyCommandEvent swig_types[94]
1530 #define SWIGTYPE_p_wxPyDropTarget swig_types[95]
1531 #define SWIGTYPE_p_wxPyEvent swig_types[96]
1532 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[97]
1533 #define SWIGTYPE_p_wxPyImageHandler swig_types[98]
1534 #define SWIGTYPE_p_wxPyInputStream swig_types[99]
1535 #define SWIGTYPE_p_wxPySizer swig_types[100]
1536 #define SWIGTYPE_p_wxPyValidator swig_types[101]
1537 #define SWIGTYPE_p_wxQuantize swig_types[102]
1538 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[103]
1539 #define SWIGTYPE_p_wxRealPoint swig_types[104]
1540 #define SWIGTYPE_p_wxRect swig_types[105]
1541 #define SWIGTYPE_p_wxRegion swig_types[106]
1542 #define SWIGTYPE_p_wxScrollEvent swig_types[107]
1543 #define SWIGTYPE_p_wxScrollWinEvent swig_types[108]
1544 #define SWIGTYPE_p_wxSetCursorEvent swig_types[109]
1545 #define SWIGTYPE_p_wxShowEvent swig_types[110]
1546 #define SWIGTYPE_p_wxSize swig_types[111]
1547 #define SWIGTYPE_p_wxSizeEvent swig_types[112]
1548 #define SWIGTYPE_p_wxSizer swig_types[113]
1549 #define SWIGTYPE_p_wxSizerItem swig_types[114]
1550 #define SWIGTYPE_p_wxStaticBox swig_types[115]
1551 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[116]
1552 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[117]
1553 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[118]
1554 #define SWIGTYPE_p_wxTIFFHandler swig_types[119]
1555 #define SWIGTYPE_p_wxToolTip swig_types[120]
1556 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[121]
1557 #define SWIGTYPE_p_wxValidator swig_types[122]
1558 #define SWIGTYPE_p_wxVisualAttributes swig_types[123]
1559 #define SWIGTYPE_p_wxWindow swig_types[124]
1560 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[125]
1561 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[126]
1562 #define SWIGTYPE_p_wxXPMHandler swig_types[127]
1563 #define SWIGTYPE_p_wxZipFSHandler swig_types[128]
1564 #define SWIGTYPE_ptrdiff_t swig_types[129]
1565 #define SWIGTYPE_std__ptrdiff_t swig_types[130]
1566 #define SWIGTYPE_unsigned_int swig_types[131]
1567 static swig_type_info *swig_types[133];
1568 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
1569 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1570 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1571
1572 /* -------- TYPES TABLE (END) -------- */
1573
1574
1575 /*-----------------------------------------------
1576 @(target):= _core_.so
1577 ------------------------------------------------*/
1578 #define SWIG_init init_core_
1579
1580 #define SWIG_name "_core_"
1581
1582 #include "wx/wxPython/wxPython_int.h"
1583 #include "wx/wxPython/pyclasses.h"
1584
1585
1586 #ifndef wxPyUSE_EXPORT
1587 // Helper functions for dealing with SWIG objects and such. These are
1588 // located here so they know about the SWIG types and functions declared
1589 // in the wrapper code.
1590
1591 #include <wx/hashmap.h>
1592 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1593
1594
1595 // Maintains a hashmap of className to swig_type_info pointers. Given the
1596 // name of a class either looks up the type info in the cache, or scans the
1597 // SWIG tables for it.
1598 extern PyObject* wxPyPtrTypeMap;
1599 static
1600 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1601
1602 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1603
1604 if (typeInfoCache == NULL)
1605 typeInfoCache = new wxPyTypeInfoHashMap;
1606
1607 wxString name(className);
1608 swig_type_info* swigType = (*typeInfoCache)[name];
1609
1610 if (! swigType) {
1611 // it wasn't in the cache, so look it up from SWIG
1612 name.Append(wxT(" *"));
1613 swigType = SWIG_TypeQuery(name.mb_str());
1614
1615 // if it still wasn't found, try looking for a mapped name
1616 if (!swigType) {
1617 PyObject* item;
1618 name = className;
1619
1620 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1621 (char*)(const char*)name.mbc_str())) != NULL) {
1622 name = wxString(PyString_AsString(item), *wxConvCurrent);
1623 name.Append(wxT(" *"));
1624 swigType = SWIG_TypeQuery(name.mb_str());
1625 }
1626 }
1627 if (swigType) {
1628 // and add it to the map if found
1629 (*typeInfoCache)[className] = swigType;
1630 }
1631 }
1632 return swigType;
1633 }
1634
1635
1636 // Check if a class name is a type known to SWIG
1637 bool wxPyCheckSwigType(const wxChar* className) {
1638
1639 swig_type_info* swigType = wxPyFindSwigType(className);
1640 return swigType != NULL;
1641 }
1642
1643
1644 // Given a pointer to a C++ object and a class name, construct a Python proxy
1645 // object for it.
1646 PyObject* wxPyConstructObject(void* ptr,
1647 const wxChar* className,
1648 int setThisOwn) {
1649
1650 swig_type_info* swigType = wxPyFindSwigType(className);
1651 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1652
1653 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1654 }
1655
1656
1657 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1658 // Ensures that the proxy object is of the specified (or derived) type. If
1659 // not able to perform the conversion then a Python exception is set and the
1660 // error should be handled properly in the caller. Returns True on success.
1661 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1662 const wxChar* className) {
1663
1664 swig_type_info* swigType = wxPyFindSwigType(className);
1665 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1666
1667 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1668 }
1669
1670
1671 // Make a SWIGified pointer object suitable for a .this attribute
1672 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1673
1674 PyObject* robj = NULL;
1675
1676 swig_type_info* swigType = wxPyFindSwigType(className);
1677 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
1678
1679 #if SWIG_VERSION < 0x010328
1680 #ifdef SWIG_COBJECT_TYPES
1681 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1682 #else
1683 {
1684 char result[1024];
1685 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1686 PyString_FromString(result) : 0;
1687 }
1688 #endif
1689 #else // SWIG_VERSION >= 1.3.28
1690 robj = PySwigObject_New(ptr, swigType, 0);
1691 #endif
1692 return robj;
1693 }
1694
1695
1696 // Python's PyInstance_Check does not return True for instances of new-style
1697 // classes. This should get close enough for both new and old classes but I
1698 // should re-evaluate the need for doing instance checks...
1699 bool wxPyInstance_Check(PyObject* obj) {
1700 return PyObject_HasAttrString(obj, "__class__") != 0;
1701 }
1702
1703
1704
1705 // This one checks if the object is an instance of a SWIG proxy class (it has
1706 // a .this attribute, and the .this attribute is a PySwigObject.)
1707 bool wxPySwigInstance_Check(PyObject* obj) {
1708 static PyObject* this_str = NULL;
1709 if (this_str == NULL)
1710 this_str = PyString_FromString("this");
1711
1712 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
1713 if (this_attr) {
1714 bool retval = (PySwigObject_Check(this_attr) != 0);
1715 Py_DECREF(this_attr);
1716 return retval;
1717 }
1718
1719 PyErr_Clear();
1720 return false;
1721 }
1722
1723
1724
1725 // Export a C API in a struct. Other modules will be able to load this from
1726 // the wx._core_ module and will then have safe access to these functions,
1727 // even if they are located in another shared library.
1728 static wxPyCoreAPI API = {
1729
1730 wxPyCheckSwigType,
1731 wxPyConstructObject,
1732 wxPyConvertSwigPtr,
1733 wxPyMakeSwigPtr,
1734
1735 wxPyBeginAllowThreads,
1736 wxPyEndAllowThreads,
1737 wxPyBeginBlockThreads,
1738 wxPyEndBlockThreads,
1739
1740 wxPy_ConvertList,
1741
1742 wxString_in_helper,
1743 Py2wxString,
1744 wx2PyString,
1745
1746 byte_LIST_helper,
1747 int_LIST_helper,
1748 long_LIST_helper,
1749 string_LIST_helper,
1750 wxPoint_LIST_helper,
1751 wxBitmap_LIST_helper,
1752 wxString_LIST_helper,
1753 wxAcceleratorEntry_LIST_helper,
1754
1755 wxSize_helper,
1756 wxPoint_helper,
1757 wxRealPoint_helper,
1758 wxRect_helper,
1759 wxColour_helper,
1760 wxPoint2D_helper,
1761
1762 wxPySimple_typecheck,
1763 wxColour_typecheck,
1764
1765 wxPyCBH_setCallbackInfo,
1766 wxPyCBH_findCallback,
1767 wxPyCBH_callCallback,
1768 wxPyCBH_callCallbackObj,
1769 wxPyCBH_delete,
1770
1771 wxPyMake_wxObject,
1772 wxPyMake_wxSizer,
1773 wxPyPtrTypeMap_Add,
1774 wxPy2int_seq_helper,
1775 wxPy4int_seq_helper,
1776 wxArrayString2PyList_helper,
1777 wxArrayInt2PyList_helper,
1778
1779 wxPyClientData_dtor,
1780 wxPyUserData_dtor,
1781 wxPyOORClientData_dtor,
1782
1783 wxPyCBInputStream_create,
1784 wxPyCBInputStream_copy,
1785
1786 wxPyInstance_Check,
1787 wxPySwigInstance_Check,
1788
1789 wxPyCheckForApp
1790
1791 };
1792
1793 #endif
1794
1795
1796 #if !WXWIN_COMPATIBILITY_2_4
1797 #define wxHIDE_READONLY 0
1798 #endif
1799
1800
1801 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
1802 #define SWIG_From_int PyInt_FromLong
1803 /*@@*/
1804
1805 static const wxString wxPyEmptyString(wxEmptyString);
1806 static wxString wxObject_GetClassName(wxObject *self){
1807 return self->GetClassInfo()->GetClassName();
1808 }
1809 static void wxObject_Destroy(wxObject *self){
1810 delete self;
1811 }
1812
1813 #ifndef __WXMAC__
1814 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1815 #endif
1816
1817
1818 #include <limits.h>
1819
1820
1821 SWIGINTERN int
1822 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1823 const char *errmsg)
1824 {
1825 if (value < min_value) {
1826 if (errmsg) {
1827 PyErr_Format(PyExc_OverflowError,
1828 "value %ld is less than '%s' minimum %ld",
1829 value, errmsg, min_value);
1830 }
1831 return 0;
1832 } else if (value > max_value) {
1833 if (errmsg) {
1834 PyErr_Format(PyExc_OverflowError,
1835 "value %ld is greater than '%s' maximum %ld",
1836 value, errmsg, max_value);
1837 }
1838 return 0;
1839 }
1840 return 1;
1841 }
1842
1843
1844 SWIGINTERN int
1845 SWIG_AsVal_long(PyObject* obj, long* val)
1846 {
1847 if (PyNumber_Check(obj)) {
1848 if (val) *val = PyInt_AsLong(obj);
1849 return 1;
1850 }
1851 else {
1852 SWIG_Python_TypeError("number", obj);
1853 }
1854 return 0;
1855 }
1856
1857
1858 #if INT_MAX != LONG_MAX
1859 SWIGINTERN int
1860 SWIG_AsVal_int(PyObject *obj, int *val)
1861 {
1862 const char* errmsg = val ? "int" : (char*)0;
1863 long v;
1864 if (SWIG_AsVal_long(obj, &v)) {
1865 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1866 if (val) *val = static_cast<int >(v);
1867 return 1;
1868 } else {
1869 return 0;
1870 }
1871 } else {
1872 PyErr_Clear();
1873 }
1874 if (val) {
1875 SWIG_type_error(errmsg, obj);
1876 }
1877 return 0;
1878 }
1879 #else
1880 SWIGINTERNINLINE int
1881 SWIG_AsVal_int(PyObject *obj, int *val)
1882 {
1883 return SWIG_AsVal_long(obj,(long*)val);
1884 }
1885 #endif
1886
1887
1888 SWIGINTERNINLINE int
1889 SWIG_As_int(PyObject* obj)
1890 {
1891 int v;
1892 if (!SWIG_AsVal_int(obj, &v)) {
1893 /*
1894 this is needed to make valgrind/purify happier.
1895 */
1896 memset((void*)&v, 0, sizeof(int));
1897 }
1898 return v;
1899 }
1900
1901
1902 SWIGINTERNINLINE int
1903 SWIG_Check_int(PyObject* obj)
1904 {
1905 return SWIG_AsVal_int(obj, (int*)0);
1906 }
1907
1908 static PyObject *wxSize_Get(wxSize *self){
1909 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1910 PyObject* tup = PyTuple_New(2);
1911 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1912 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1913 wxPyEndBlockThreads(blocked);
1914 return tup;
1915 }
1916
1917 SWIGINTERN int
1918 SWIG_AsVal_double(PyObject *obj, double* val)
1919 {
1920 if (PyNumber_Check(obj)) {
1921 if (val) *val = PyFloat_AsDouble(obj);
1922 return 1;
1923 }
1924 else {
1925 SWIG_Python_TypeError("number", obj);
1926 }
1927 return 0;
1928 }
1929
1930
1931 SWIGINTERNINLINE double
1932 SWIG_As_double(PyObject* obj)
1933 {
1934 double v;
1935 if (!SWIG_AsVal_double(obj, &v)) {
1936 /*
1937 this is needed to make valgrind/purify happier.
1938 */
1939 memset((void*)&v, 0, sizeof(double));
1940 }
1941 return v;
1942 }
1943
1944
1945 SWIGINTERNINLINE int
1946 SWIG_Check_double(PyObject* obj)
1947 {
1948 return SWIG_AsVal_double(obj, (double*)0);
1949 }
1950
1951
1952 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
1953 #define SWIG_From_double PyFloat_FromDouble
1954 /*@@*/
1955
1956 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1957 self->x = x;
1958 self->y = y;
1959 }
1960 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1961 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1962 PyObject* tup = PyTuple_New(2);
1963 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1964 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1965 wxPyEndBlockThreads(blocked);
1966 return tup;
1967 }
1968
1969 SWIGINTERNINLINE long
1970 SWIG_As_long(PyObject* obj)
1971 {
1972 long v;
1973 if (!SWIG_AsVal_long(obj, &v)) {
1974 /*
1975 this is needed to make valgrind/purify happier.
1976 */
1977 memset((void*)&v, 0, sizeof(long));
1978 }
1979 return v;
1980 }
1981
1982
1983 SWIGINTERNINLINE int
1984 SWIG_Check_long(PyObject* obj)
1985 {
1986 return SWIG_AsVal_long(obj, (long*)0);
1987 }
1988
1989 static void wxPoint_Set(wxPoint *self,long x,long y){
1990 self->x = x;
1991 self->y = y;
1992 }
1993 static PyObject *wxPoint_Get(wxPoint *self){
1994 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1995 PyObject* tup = PyTuple_New(2);
1996 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1997 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1998 wxPyEndBlockThreads(blocked);
1999 return tup;
2000 }
2001 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
2002 self->x = x;
2003 self->y = y;
2004 self->width = width;
2005 self->height = height;
2006 }
2007 static PyObject *wxRect_Get(wxRect *self){
2008 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2009 PyObject* tup = PyTuple_New(4);
2010 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2011 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2012 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
2013 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
2014 wxPyEndBlockThreads(blocked);
2015 return tup;
2016 }
2017
2018 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
2019 wxRegion reg1(*r1);
2020 wxRegion reg2(*r2);
2021 wxRect dest(0,0,0,0);
2022 PyObject* obj;
2023
2024 reg1.Intersect(reg2);
2025 dest = reg1.GetBox();
2026
2027 if (dest != wxRect(0,0,0,0)) {
2028 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2029 wxRect* newRect = new wxRect(dest);
2030 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
2031 wxPyEndBlockThreads(blocked);
2032 return obj;
2033 }
2034 Py_INCREF(Py_None);
2035 return Py_None;
2036 }
2037
2038
2039 static PyObject* t_output_helper(PyObject* result, PyObject* obj)
2040 {
2041 PyObject* o2;
2042 PyObject* o3;
2043 if (!result) {
2044 result = obj;
2045 } else if (result == Py_None) {
2046 Py_DECREF(result);
2047 result = obj;
2048 } else {
2049 if (!PyTuple_Check(result)) {
2050 o2 = result;
2051 result = PyTuple_New(1);
2052 PyTuple_SET_ITEM(result, 0, o2);
2053 }
2054 o3 = PyTuple_New(1);
2055 PyTuple_SetItem(o3, 0, obj);
2056 o2 = result;
2057 result = PySequence_Concat(o2, o3);
2058 Py_DECREF(o2);
2059 Py_DECREF(o3);
2060 }
2061 return result;
2062 }
2063
2064
2065 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
2066 self->m_x = x;
2067 self->m_y = y;
2068 }
2069 static PyObject *wxPoint2D_Get(wxPoint2D *self){
2070 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2071 PyObject* tup = PyTuple_New(2);
2072 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
2073 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
2074 wxPyEndBlockThreads(blocked);
2075 return tup;
2076 }
2077
2078 #include "wx/wxPython/pyistream.h"
2079
2080 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
2081 wxInputStream* wxis = wxPyCBInputStream::create(p);
2082 if (wxis)
2083 return new wxPyInputStream(wxis);
2084 else
2085 return NULL;
2086 }
2087
2088 SWIGINTERNINLINE PyObject*
2089 SWIG_From_char(char c)
2090 {
2091 return PyString_FromStringAndSize(&c,1);
2092 }
2093
2094
2095 SWIGINTERNINLINE PyObject*
2096 SWIG_From_unsigned_SS_long(unsigned long value)
2097 {
2098 return (value > LONG_MAX) ?
2099 PyLong_FromUnsignedLong(value)
2100 : PyInt_FromLong(static_cast<long >(value));
2101 }
2102
2103
2104 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
2105 SWIGINTERN int
2106 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
2107 {
2108 static swig_type_info* pchar_info = 0;
2109 char* vptr = 0;
2110 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
2111 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
2112 if (cptr) *cptr = vptr;
2113 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
2114 return SWIG_OLDOBJ;
2115 } else {
2116 PyErr_Clear();
2117 if (PyString_Check(obj)) {
2118 if (cptr) {
2119 *cptr = PyString_AS_STRING(obj);
2120 if (psize) {
2121 *psize = PyString_GET_SIZE(obj) + 1;
2122 }
2123 }
2124 return SWIG_PYSTR;
2125 }
2126 }
2127 if (cptr) {
2128 SWIG_type_error("char *", obj);
2129 }
2130 return 0;
2131 }
2132
2133
2134 SWIGINTERN int
2135 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2136 {
2137 char* cptr; size_t csize;
2138 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2139 /* in C you can do:
2140
2141 char x[5] = "hello";
2142
2143 ie, assing the array using an extra '0' char.
2144 */
2145 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2146 if (csize <= size) {
2147 if (val) {
2148 if (csize) memcpy(val, cptr, csize);
2149 if (csize < size) memset(val + csize, 0, size - csize);
2150 }
2151 return 1;
2152 }
2153 }
2154 if (val) {
2155 PyErr_Format(PyExc_TypeError,
2156 "a char array of maximum size %lu is expected",
2157 (unsigned long) size);
2158 }
2159 return 0;
2160 }
2161
2162
2163 SWIGINTERN int
2164 SWIG_AsVal_char(PyObject *obj, char *val)
2165 {
2166 const char* errmsg = val ? "char" : (char*)0;
2167 long v;
2168 if (SWIG_AsVal_long(obj, &v)) {
2169 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2170 if (val) *val = static_cast<char >(v);
2171 return 1;
2172 } else {
2173 return 0;
2174 }
2175 } else {
2176 PyErr_Clear();
2177 return SWIG_AsCharArray(obj, val, 1);
2178 }
2179 }
2180
2181
2182 SWIGINTERNINLINE char
2183 SWIG_As_char(PyObject* obj)
2184 {
2185 char v;
2186 if (!SWIG_AsVal_char(obj, &v)) {
2187 /*
2188 this is needed to make valgrind/purify happier.
2189 */
2190 memset((void*)&v, 0, sizeof(char));
2191 }
2192 return v;
2193 }
2194
2195
2196 SWIGINTERNINLINE int
2197 SWIG_Check_char(PyObject* obj)
2198 {
2199 return SWIG_AsVal_char(obj, (char*)0);
2200 }
2201
2202
2203 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2204 #define SWIG_From_long PyInt_FromLong
2205 /*@@*/
2206
2207 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2208 // We use only strings for the streams, not unicode
2209 PyObject* str = PyObject_Str(obj);
2210 if (! str) {
2211 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2212 return;
2213 }
2214 self->Write(PyString_AS_STRING(str),
2215 PyString_GET_SIZE(str));
2216 Py_DECREF(str);
2217 }
2218
2219 #include "wx/wxPython/pyistream.h"
2220
2221
2222 class wxPyFileSystemHandler : public wxFileSystemHandler
2223 {
2224 public:
2225 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2226
2227 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2228 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2229 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2230 DEC_PYCALLBACK_STRING__pure(FindNext);
2231
2232 wxString GetProtocol(const wxString& location) {
2233 return wxFileSystemHandler::GetProtocol(location);
2234 }
2235
2236 wxString GetLeftLocation(const wxString& location) {
2237 return wxFileSystemHandler::GetLeftLocation(location);
2238 }
2239
2240 wxString GetAnchor(const wxString& location) {
2241 return wxFileSystemHandler::GetAnchor(location);
2242 }
2243
2244 wxString GetRightLocation(const wxString& location) {
2245 return wxFileSystemHandler::GetRightLocation(location);
2246 }
2247
2248 wxString GetMimeTypeFromExt(const wxString& location) {
2249 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2250 }
2251
2252 PYPRIVATE;
2253 };
2254
2255
2256 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2257 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2258 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2259 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2260
2261
2262 SWIGINTERN int
2263 SWIG_AsVal_bool(PyObject *obj, bool *val)
2264 {
2265 if (obj == Py_True) {
2266 if (val) *val = true;
2267 return 1;
2268 }
2269 if (obj == Py_False) {
2270 if (val) *val = false;
2271 return 1;
2272 }
2273 int res = 0;
2274 if (SWIG_AsVal_int(obj, &res)) {
2275 if (val) *val = res ? true : false;
2276 return 1;
2277 } else {
2278 PyErr_Clear();
2279 }
2280 if (val) {
2281 SWIG_type_error("bool", obj);
2282 }
2283 return 0;
2284 }
2285
2286
2287 SWIGINTERNINLINE bool
2288 SWIG_As_bool(PyObject* obj)
2289 {
2290 bool v;
2291 if (!SWIG_AsVal_bool(obj, &v)) {
2292 /*
2293 this is needed to make valgrind/purify happier.
2294 */
2295 memset((void*)&v, 0, sizeof(bool));
2296 }
2297 return v;
2298 }
2299
2300
2301 SWIGINTERNINLINE int
2302 SWIG_Check_bool(PyObject* obj)
2303 {
2304 return SWIG_AsVal_bool(obj, (bool*)0);
2305 }
2306
2307 static wxString wxFileSystem_URLToFileName(wxString const &url){
2308 wxFileName fname = wxFileSystem::URLToFileName(url);
2309 return fname.GetFullPath();
2310 }
2311
2312 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2313 wxImage& image,
2314 long type) {
2315 wxMemoryFSHandler::AddFile(filename, image, type);
2316 }
2317
2318 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2319 const wxBitmap& bitmap,
2320 long type) {
2321 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2322 }
2323
2324 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2325 PyObject* data) {
2326 if (! PyString_Check(data)) {
2327 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2328 "Expected string object"));
2329 return;
2330 }
2331
2332 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2333 void* ptr = (void*)PyString_AsString(data);
2334 size_t size = PyString_Size(data);
2335 wxPyEndBlockThreads(blocked);
2336
2337 wxMemoryFSHandler::AddFile(filename, ptr, size);
2338 }
2339
2340
2341 #include "wx/wxPython/pyistream.h"
2342
2343
2344 SWIGINTERN int
2345 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2346 {
2347 long v = 0;
2348 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2349 SWIG_Python_TypeError("unsigned number", obj);
2350 }
2351 else if (val)
2352 *val = (unsigned long)v;
2353 return 1;
2354 }
2355
2356
2357 SWIGINTERNINLINE int
2358 SWIG_CheckUnsignedLongInRange(unsigned long value,
2359 unsigned long max_value,
2360 const char *errmsg)
2361 {
2362 if (value > max_value) {
2363 if (errmsg) {
2364 PyErr_Format(PyExc_OverflowError,
2365 "value %lu is greater than '%s' minimum %lu",
2366 value, errmsg, max_value);
2367 }
2368 return 0;
2369 }
2370 return 1;
2371 }
2372
2373
2374 SWIGINTERN int
2375 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2376 {
2377 const char* errmsg = val ? "unsigned char" : (char*)0;
2378 unsigned long v;
2379 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2380 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2381 if (val) *val = static_cast<unsigned char >(v);
2382 return 1;
2383 } else {
2384 return 0;
2385 }
2386 } else {
2387 PyErr_Clear();
2388 }
2389 if (val) {
2390 SWIG_type_error(errmsg, obj);
2391 }
2392 return 0;
2393 }
2394
2395
2396 SWIGINTERNINLINE unsigned char
2397 SWIG_As_unsigned_SS_char(PyObject* obj)
2398 {
2399 unsigned char v;
2400 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2401 /*
2402 this is needed to make valgrind/purify happier.
2403 */
2404 memset((void*)&v, 0, sizeof(unsigned char));
2405 }
2406 return v;
2407 }
2408
2409
2410 SWIGINTERNINLINE int
2411 SWIG_Check_unsigned_SS_char(PyObject* obj)
2412 {
2413 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2414 }
2415
2416
2417 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2418 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2419 /*@@*/
2420
2421
2422
2423 SWIGINTERNINLINE unsigned long
2424 SWIG_As_unsigned_SS_long(PyObject* obj)
2425 {
2426 unsigned long v;
2427 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2428 /*
2429 this is needed to make valgrind/purify happier.
2430 */
2431 memset((void*)&v, 0, sizeof(unsigned long));
2432 }
2433 return v;
2434 }
2435
2436
2437 SWIGINTERNINLINE int
2438 SWIG_Check_unsigned_SS_long(PyObject* obj)
2439 {
2440 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2441 }
2442
2443 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2444 wxImageHistogramEntry e = (*self)[key];
2445 return e.value;
2446 }
2447 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
2448 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2449 wxImageHistogramEntry e = (*self)[key];
2450 return e.value;
2451 }
2452 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2453 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2454 colour.Green(),
2455 colour.Blue());
2456 wxImageHistogramEntry e = (*self)[key];
2457 return e.value;
2458 }
2459
2460 typedef unsigned char* buffer;
2461
2462
2463 // Pull the nested class out to the top level for SWIG's sake
2464 #define wxImage_RGBValue wxImage::RGBValue
2465 #define wxImage_HSVValue wxImage::HSVValue
2466
2467 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2468 if (width > 0 && height > 0)
2469 return new wxImage(width, height, clear);
2470 else
2471 return new wxImage;
2472 }
2473 static wxImage *new_wxImage(wxBitmap const &bitmap){
2474 return new wxImage(bitmap.ConvertToImage());
2475 }
2476 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2477 if (DATASIZE != width*height*3) {
2478 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2479 return NULL;
2480 }
2481
2482 // Copy the source data so the wxImage can clean it up later
2483 buffer copy = (buffer)malloc(DATASIZE);
2484 if (copy == NULL) {
2485 wxPyBLOCK_THREADS(PyErr_NoMemory());
2486 return NULL;
2487 }
2488 memcpy(copy, data, DATASIZE);
2489 return new wxImage(width, height, copy, false);
2490 }
2491 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2492 if (DATASIZE != width*height*3) {
2493 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2494 return NULL;
2495 }
2496 if (ALPHASIZE != width*height) {
2497 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2498 return NULL;
2499 }
2500
2501 // Copy the source data so the wxImage can clean it up later
2502 buffer dcopy = (buffer)malloc(DATASIZE);
2503 if (dcopy == NULL) {
2504 wxPyBLOCK_THREADS(PyErr_NoMemory());
2505 return NULL;
2506 }
2507 memcpy(dcopy, data, DATASIZE);
2508
2509 buffer acopy = (buffer)malloc(ALPHASIZE);
2510 if (acopy == NULL) {
2511 wxPyBLOCK_THREADS(PyErr_NoMemory());
2512 return NULL;
2513 }
2514 memcpy(acopy, alpha, ALPHASIZE);
2515
2516 return new wxImage(width, height, dcopy, acopy, false);
2517 }
2518 static wxSize wxImage_GetSize(wxImage *self){
2519 wxSize size(self->GetWidth(), self->GetHeight());
2520 return size;
2521 }
2522 static PyObject *wxImage_GetData(wxImage *self){
2523 buffer data = self->GetData();
2524 int len = self->GetWidth() * self->GetHeight() * 3;
2525 PyObject* rv;
2526 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2527 return rv;
2528 }
2529 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2530 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2531 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2532 return;
2533 }
2534 buffer copy = (buffer)malloc(DATASIZE);
2535 if (copy == NULL) {
2536 wxPyBLOCK_THREADS(PyErr_NoMemory());
2537 return;
2538 }
2539 memcpy(copy, data, DATASIZE);
2540 self->SetData(copy, false);
2541 // wxImage takes ownership of copy...
2542 }
2543 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2544 buffer data = self->GetData();
2545 int len = self->GetWidth() * self->GetHeight() * 3;
2546 PyObject* rv;
2547 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2548 return rv;
2549 }
2550 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2551 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2552 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2553 return;
2554 }
2555 self->SetData(data, true);
2556 }
2557 static PyObject *wxImage_GetAlphaData(wxImage *self){
2558 buffer data = self->GetAlpha();
2559 if (! data) {
2560 RETURN_NONE();
2561 } else {
2562 int len = self->GetWidth() * self->GetHeight();
2563 PyObject* rv;
2564 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2565 return rv;
2566 }
2567 }
2568 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2569 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2570 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2571 return;
2572 }
2573 buffer acopy = (buffer)malloc(ALPHASIZE);
2574 if (acopy == NULL) {
2575 wxPyBLOCK_THREADS(PyErr_NoMemory());
2576 return;
2577 }
2578 memcpy(acopy, alpha, ALPHASIZE);
2579 self->SetAlpha(acopy, false);
2580 // wxImage takes ownership of acopy...
2581 }
2582 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2583 buffer data = self->GetAlpha();
2584 int len = self->GetWidth() * self->GetHeight();
2585 PyObject* rv;
2586 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2587 return rv;
2588 }
2589 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2590 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2591 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2592 return;
2593 }
2594 self->SetAlpha(alpha, true);
2595 }
2596 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2597 wxBitmap bitmap(*self, depth);
2598 return bitmap;
2599 }
2600 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
2601 wxImage mono = self->ConvertToMono( red, green, blue );
2602 wxBitmap bitmap( mono, 1 );
2603 return bitmap;
2604 }
2605 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2606 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2607 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2608 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2609 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2610 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2611 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2612 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2613 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2614 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2615 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2616 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2617 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2618 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2619 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2620
2621 #include <wx/quantize.h>
2622
2623 static bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2624 return wxQuantize::Quantize(src, dest,
2625 //NULL, // palette
2626 desiredNoColours,
2627 NULL, // eightBitData
2628 flags);
2629 }
2630 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2631 if (PyCallable_Check(func)) {
2632 self->Connect(id, lastId, eventType,
2633 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2634 new wxPyCallback(func));
2635 }
2636 else if (func == Py_None) {
2637 self->Disconnect(id, lastId, eventType,
2638 (wxObjectEventFunction)
2639 &wxPyCallback::EventThunker);
2640 }
2641 else {
2642 wxPyBLOCK_THREADS(
2643 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2644 }
2645 }
2646 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2647 return self->Disconnect(id, lastId, eventType,
2648 (wxObjectEventFunction)
2649 &wxPyCallback::EventThunker);
2650 }
2651 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2652 if (_self && _self != Py_None) {
2653 self->SetClientObject(new wxPyOORClientData(_self, incref));
2654 }
2655 else {
2656 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2657 if (data) {
2658 self->SetClientObject(NULL); // This will delete it too
2659 }
2660 }
2661 }
2662
2663 #if ! wxUSE_HOTKEY
2664 #define wxEVT_HOTKEY -9999
2665 #endif
2666
2667
2668 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2669 #if wxUSE_UNICODE
2670 return self->GetUnicodeKey();
2671 #else
2672 return 0;
2673 #endif
2674 }
2675
2676 #if UINT_MAX < LONG_MAX
2677 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2678 #define SWIG_From_unsigned_SS_int SWIG_From_long
2679 /*@@*/
2680 #else
2681 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
2682 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2683 /*@@*/
2684 #endif
2685
2686
2687 #if UINT_MAX != ULONG_MAX
2688 SWIGINTERN int
2689 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2690 {
2691 const char* errmsg = val ? "unsigned int" : (char*)0;
2692 unsigned long v;
2693 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2694 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2695 if (val) *val = static_cast<unsigned int >(v);
2696 return 1;
2697 }
2698 } else {
2699 PyErr_Clear();
2700 }
2701 if (val) {
2702 SWIG_type_error(errmsg, obj);
2703 }
2704 return 0;
2705 }
2706 #else
2707 SWIGINTERNINLINE unsigned int
2708 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2709 {
2710 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2711 }
2712 #endif
2713
2714
2715 SWIGINTERNINLINE unsigned int
2716 SWIG_As_unsigned_SS_int(PyObject* obj)
2717 {
2718 unsigned int v;
2719 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2720 /*
2721 this is needed to make valgrind/purify happier.
2722 */
2723 memset((void*)&v, 0, sizeof(unsigned int));
2724 }
2725 return v;
2726 }
2727
2728
2729 SWIGINTERNINLINE int
2730 SWIG_Check_unsigned_SS_int(PyObject* obj)
2731 {
2732 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2733 }
2734
2735 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2736 self->m_size = size;
2737 }
2738 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2739 int count = self->GetNumberOfFiles();
2740 wxString* files = self->GetFiles();
2741 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2742 PyObject* list = PyList_New(count);
2743
2744 if (!list) {
2745 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2746 wxPyEndBlockThreads(blocked);
2747 return NULL;
2748 }
2749
2750 for (int i=0; i<count; i++) {
2751 PyList_SetItem(list, i, wx2PyString(files[i]));
2752 }
2753 wxPyEndBlockThreads(blocked);
2754 return list;
2755 }
2756
2757
2758 static wxPyApp *new_wxPyApp(){
2759 wxPythonApp = new wxPyApp();
2760 return wxPythonApp;
2761 }
2762 static int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2763
2764 void wxApp_CleanUp() {
2765 __wxPyCleanup();
2766 }
2767
2768
2769 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2770
2771
2772 SWIGINTERNINLINE int
2773 SWIG_AsCharPtr(PyObject *obj, char **val)
2774 {
2775 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2776 return 1;
2777 }
2778 if (val) {
2779 PyErr_Clear();
2780 SWIG_type_error("char *", obj);
2781 }
2782 return 0;
2783 }
2784
2785
2786 SWIGINTERN PyObject *
2787 SWIG_FromCharPtr(const char* cptr)
2788 {
2789 if (cptr) {
2790 size_t size = strlen(cptr);
2791 if (size > INT_MAX) {
2792 return SWIG_NewPointerObj(const_cast<char* >(cptr),
2793 SWIG_TypeQuery("char *"), 0);
2794 } else {
2795 if (size != 0) {
2796 return PyString_FromStringAndSize(cptr, size);
2797 } else {
2798 return PyString_FromString(cptr);
2799 }
2800 }
2801 }
2802 Py_INCREF(Py_None);
2803 return Py_None;
2804 }
2805
2806
2807 #if 0 // #ifdef __WXMAC__
2808
2809 // A dummy class that raises an exception if used...
2810 class wxEventLoop
2811 {
2812 public:
2813 wxEventLoop() { wxPyRaiseNotImplemented(); }
2814 int Run() { return 0; }
2815 void Exit(int rc = 0) {}
2816 bool Pending() const { return false; }
2817 bool Dispatch() { return false; }
2818 bool IsRunning() const { return false; }
2819 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2820 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2821 };
2822
2823 #else
2824
2825 #include <wx/evtloop.h>
2826
2827 #endif
2828
2829
2830
2831 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2832 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2833 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2834 static PyObject *wxWindow_GetChildren(wxWindow *self){
2835 wxWindowList& list = self->GetChildren();
2836 return wxPy_ConvertList(&list);
2837 }
2838 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2839 #if wxUSE_HOTKEY
2840 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2841 #else
2842 return false;
2843 #endif
2844 }
2845 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2846
2847
2848
2849 return false;
2850
2851 }
2852 static long wxWindow_GetHandle(wxWindow *self){
2853 return wxPyGetWinHandle(self);
2854 }
2855 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2856 self->AssociateHandle((WXWidget)handle);
2857 }
2858 static void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
2859
2860 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2861 return wxWindow::FindWindowById(id, parent);
2862 }
2863
2864 wxWindow* wxFindWindowByName( const wxString& name,
2865 const wxWindow *parent = NULL ) {
2866 return wxWindow::FindWindowByName(name, parent);
2867 }
2868
2869 wxWindow* wxFindWindowByLabel( const wxString& label,
2870 const wxWindow *parent = NULL ) {
2871 return wxWindow::FindWindowByLabel(label, parent);
2872 }
2873
2874
2875 #ifdef __WXMSW__
2876 #include <wx/msw/private.h> // to get wxGetWindowId
2877 #endif
2878
2879
2880 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2881 #ifdef __WXMSW__
2882 WXHWND hWnd = (WXHWND)_hWnd;
2883 long id = wxGetWindowId(hWnd);
2884 wxWindow* win = new wxWindow;
2885 if (parent)
2886 parent->AddChild(win);
2887 win->SetEventHandler(win);
2888 win->SetHWND(hWnd);
2889 win->SetId(id);
2890 win->SubclassWin(hWnd);
2891 win->AdoptAttributesFromHWND();
2892 win->SetupColours();
2893 return win;
2894 #else
2895 wxPyRaiseNotImplemented();
2896 return NULL;
2897 #endif
2898 }
2899
2900
2901 PyObject* GetTopLevelWindows() {
2902 return wxPy_ConvertList(&wxTopLevelWindows);
2903 }
2904
2905
2906 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2907 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2908 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2909
2910 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2911
2912 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2913 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2914 wxMenuItemList& list = self->GetMenuItems();
2915 return wxPy_ConvertList(&list);
2916 }
2917 static void wxMenuBar_SetAutoWindowMenu(bool enable){}
2918 static bool wxMenuBar_GetAutoWindowMenu(){ return false; }
2919 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2920 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2921 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2922 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2923 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2924 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2925 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
2926 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2927 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2928 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2929 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2930 static int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
2931 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2932 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2933 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2934 static const wxString wxPyControlNameStr(wxControlNameStr);
2935 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2936 if (clientData) {
2937 wxPyClientData* data = new wxPyClientData(clientData);
2938 return self->Append(item, data);
2939 } else
2940 return self->Append(item);
2941 }
2942 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2943 if (clientData) {
2944 wxPyClientData* data = new wxPyClientData(clientData);
2945 return self->Insert(item, pos, data);
2946 } else
2947 return self->Insert(item, pos);
2948 }
2949 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2950 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2951 if (data) {
2952 Py_INCREF(data->m_obj);
2953 return data->m_obj;
2954 } else {
2955 Py_INCREF(Py_None);
2956 return Py_None;
2957 }
2958 }
2959 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2960 wxPyClientData* data = new wxPyClientData(clientData);
2961 self->SetClientObject(n, data);
2962 }
2963
2964
2965 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2966 wxPyUserData* data = NULL;
2967 if ( userData ) {
2968 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2969 data = new wxPyUserData(userData);
2970 wxPyEndBlockThreads(blocked);
2971 }
2972 return new wxSizerItem(window, proportion, flag, border, data);
2973 }
2974 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2975 wxPyUserData* data = NULL;
2976 if ( userData ) {
2977 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2978 data = new wxPyUserData(userData);
2979 wxPyEndBlockThreads(blocked);
2980 }
2981 return new wxSizerItem(width, height, proportion, flag, border, data);
2982 }
2983 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2984 wxPyUserData* data = NULL;
2985 if ( userData ) {
2986 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2987 data = new wxPyUserData(userData);
2988 wxPyEndBlockThreads(blocked);
2989 }
2990 return new wxSizerItem(sizer, proportion, flag, border, data);
2991 }
2992
2993 #include <float.h>
2994 SWIGINTERN int
2995 SWIG_CheckDoubleInRange(double value, double min_value,
2996 double max_value, const char* errmsg)
2997 {
2998 if (value < min_value) {
2999 if (errmsg) {
3000 PyErr_Format(PyExc_OverflowError,
3001 "value %g is less than %s minimum %g",
3002 value, errmsg, min_value);
3003 }
3004 return 0;
3005 } else if (value > max_value) {
3006 if (errmsg) {
3007 PyErr_Format(PyExc_OverflowError,
3008 "value %g is greater than %s maximum %g",
3009 value, errmsg, max_value);
3010 }
3011 return 0;
3012 }
3013 return 1;
3014 }
3015
3016
3017 SWIGINTERN int
3018 SWIG_AsVal_float(PyObject *obj, float *val)
3019 {
3020 const char* errmsg = val ? "float" : (char*)0;
3021 double v;
3022 if (SWIG_AsVal_double(obj, &v)) {
3023 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
3024 if (val) *val = static_cast<float >(v);
3025 return 1;
3026 } else {
3027 return 0;
3028 }
3029 } else {
3030 PyErr_Clear();
3031 }
3032 if (val) {
3033 SWIG_type_error(errmsg, obj);
3034 }
3035 return 0;
3036 }
3037
3038
3039 SWIGINTERNINLINE float
3040 SWIG_As_float(PyObject* obj)
3041 {
3042 float v;
3043 if (!SWIG_AsVal_float(obj, &v)) {
3044 /*
3045 this is needed to make valgrind/purify happier.
3046 */
3047 memset((void*)&v, 0, sizeof(float));
3048 }
3049 return v;
3050 }
3051
3052
3053 SWIGINTERNINLINE int
3054 SWIG_Check_float(PyObject* obj)
3055 {
3056 return SWIG_AsVal_float(obj, (float*)0);
3057 }
3058
3059
3060 /*@/opt/swig/share/swig/1.3.27/python/pymacros.swg,72,SWIG_define@*/
3061 #define SWIG_From_float PyFloat_FromDouble
3062 /*@@*/
3063
3064 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3065 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3066 if (data) {
3067 Py_INCREF(data->m_obj);
3068 return data->m_obj;
3069 } else {
3070 Py_INCREF(Py_None);
3071 return Py_None;
3072 }
3073 }
3074 static void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3075 wxPyUserData* data = NULL;
3076 if ( userData ) {
3077 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3078 data = new wxPyUserData(userData);
3079 wxPyEndBlockThreads(blocked);
3080 }
3081 self->SetUserData(data);
3082 }
3083
3084 // Figure out the type of the sizer item
3085
3086 struct wxPySizerItemInfo {
3087 wxPySizerItemInfo()
3088 : window(NULL), sizer(NULL), gotSize(false),
3089 size(wxDefaultSize), gotPos(false), pos(-1)
3090 {}
3091
3092 wxWindow* window;
3093 wxSizer* sizer;
3094 bool gotSize;
3095 wxSize size;
3096 bool gotPos;
3097 int pos;
3098 };
3099
3100 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
3101
3102 wxPySizerItemInfo info;
3103 wxSize size;
3104 wxSize* sizePtr = &size;
3105
3106 // Find out what the type of the item is
3107 // try wxWindow
3108 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
3109 PyErr_Clear();
3110 info.window = NULL;
3111
3112 // try wxSizer
3113 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
3114 PyErr_Clear();
3115 info.sizer = NULL;
3116
3117 // try wxSize or (w,h)
3118 if ( checkSize && wxSize_helper(item, &sizePtr)) {
3119 info.size = *sizePtr;
3120 info.gotSize = true;
3121 }
3122
3123 // or a single int
3124 if (checkIdx && PyInt_Check(item)) {
3125 info.pos = PyInt_AsLong(item);
3126 info.gotPos = true;
3127 }
3128 }
3129 }
3130
3131 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3132 // no expected type, figure out what kind of error message to generate
3133 if ( !checkSize && !checkIdx )
3134 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3135 else if ( checkSize && !checkIdx )
3136 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3137 else if ( !checkSize && checkIdx)
3138 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3139 else
3140 // can this one happen?
3141 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3142 }
3143
3144 return info;
3145 }
3146
3147 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3148 if (!self->GetClientObject())
3149 self->SetClientObject(new wxPyOORClientData(_self));
3150 }
3151 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3152
3153 wxPyUserData* data = NULL;
3154 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3155 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3156 if ( userData && (info.window || info.sizer || info.gotSize) )
3157 data = new wxPyUserData(userData);
3158 if ( info.sizer )
3159 PyObject_SetAttrString(item,"thisown",Py_False);
3160 wxPyEndBlockThreads(blocked);
3161
3162 // Now call the real Add method if a valid item type was found
3163 if ( info.window )
3164 return self->Add(info.window, proportion, flag, border, data);
3165 else if ( info.sizer )
3166 return self->Add(info.sizer, proportion, flag, border, data);
3167 else if (info.gotSize)
3168 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3169 proportion, flag, border, data);
3170 else
3171 return NULL;
3172 }
3173 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3174
3175 wxPyUserData* data = NULL;
3176 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3177 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3178 if ( userData && (info.window || info.sizer || info.gotSize) )
3179 data = new wxPyUserData(userData);
3180 if ( info.sizer )
3181 PyObject_SetAttrString(item,"thisown",Py_False);
3182 wxPyEndBlockThreads(blocked);
3183
3184 // Now call the real Insert method if a valid item type was found
3185 if ( info.window )
3186 return self->Insert(before, info.window, proportion, flag, border, data);
3187 else if ( info.sizer )
3188 return self->Insert(before, info.sizer, proportion, flag, border, data);
3189 else if (info.gotSize)
3190 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3191 proportion, flag, border, data);
3192 else
3193 return NULL;
3194 }
3195 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3196
3197 wxPyUserData* data = NULL;
3198 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3199 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3200 if ( userData && (info.window || info.sizer || info.gotSize) )
3201 data = new wxPyUserData(userData);
3202 if ( info.sizer )
3203 PyObject_SetAttrString(item,"thisown",Py_False);
3204 wxPyEndBlockThreads(blocked);
3205
3206 // Now call the real Prepend method if a valid item type was found
3207 if ( info.window )
3208 return self->Prepend(info.window, proportion, flag, border, data);
3209 else if ( info.sizer )
3210 return self->Prepend(info.sizer, proportion, flag, border, data);
3211 else if (info.gotSize)
3212 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3213 proportion, flag, border, data);
3214 else
3215 return NULL;
3216 }
3217 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3218 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3219 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3220 wxPyEndBlockThreads(blocked);
3221 if ( info.window )
3222 return self->Remove(info.window);
3223 else if ( info.sizer )
3224 return self->Remove(info.sizer);
3225 else if ( info.gotPos )
3226 return self->Remove(info.pos);
3227 else
3228 return false;
3229 }
3230 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3231 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3232 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3233 wxPyEndBlockThreads(blocked);
3234 if ( info.window )
3235 return self->Detach(info.window);
3236 else if ( info.sizer )
3237 return self->Detach(info.sizer);
3238 else if ( info.gotPos )
3239 return self->Detach(info.pos);
3240 else
3241 return false;
3242 }
3243 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3244 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3245 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3246 wxPyEndBlockThreads(blocked);
3247 if ( info.window )
3248 return self->GetItem(info.window);
3249 else if ( info.sizer )
3250 return self->GetItem(info.sizer);
3251 else if ( info.gotPos )
3252 return self->GetItem(info.pos);
3253 else
3254 return NULL;
3255 }
3256 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3257 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3258 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3259 wxPyEndBlockThreads(blocked);
3260 if ( info.window )
3261 self->SetItemMinSize(info.window, size);
3262 else if ( info.sizer )
3263 self->SetItemMinSize(info.sizer, size);
3264 else if ( info.gotPos )
3265 self->SetItemMinSize(info.pos, size);
3266 }
3267 static PyObject *wxSizer_GetChildren(wxSizer *self){
3268 wxSizerItemList& list = self->GetChildren();
3269 return wxPy_ConvertList(&list);
3270 }
3271 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3272 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3273 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3274 wxPyEndBlockThreads(blocked);
3275 if ( info.window )
3276 return self->Show(info.window, show, recursive);
3277 else if ( info.sizer )
3278 return self->Show(info.sizer, show, recursive);
3279 else if ( info.gotPos )
3280 return self->Show(info.pos, show);
3281 else
3282 return false;
3283 }
3284 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3285 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3286 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3287 wxPyEndBlockThreads(blocked);
3288 if ( info.window )
3289 return self->IsShown(info.window);
3290 else if ( info.sizer )
3291 return self->IsShown(info.sizer);
3292 else if ( info.gotPos )
3293 return self->IsShown(info.pos);
3294 else
3295 return false;
3296 }
3297
3298 // See pyclasses.h
3299 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3300 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3301 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3302
3303
3304
3305
3306 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3307 {
3308 if (source == Py_None) {
3309 **obj = wxGBPosition(-1,-1);
3310 return true;
3311 }
3312 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3313 }
3314
3315 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3316 {
3317 if (source == Py_None) {
3318 **obj = wxGBSpan(-1,-1);
3319 return true;
3320 }
3321 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3322 }
3323
3324
3325 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3326 self->SetRow(row);
3327 self->SetCol(col);
3328 }
3329 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3330 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3331 PyObject* tup = PyTuple_New(2);
3332 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3333 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3334 wxPyEndBlockThreads(blocked);
3335 return tup;
3336 }
3337 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3338 self->SetRowspan(rowspan);
3339 self->SetColspan(colspan);
3340 }
3341 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3342 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3343 PyObject* tup = PyTuple_New(2);
3344 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3345 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3346 wxPyEndBlockThreads(blocked);
3347 return tup;
3348 }
3349 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3350 wxPyUserData* data = NULL;
3351 if ( userData ) {
3352 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3353 data = new wxPyUserData(userData);
3354 wxPyEndBlockThreads(blocked);
3355 }
3356 return new wxGBSizerItem(window, pos, span, flag, border, data);
3357 }
3358 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3359 wxPyUserData* data = NULL;
3360 if ( userData ) {
3361 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3362 data = new wxPyUserData(userData);
3363 wxPyEndBlockThreads(blocked);
3364 }
3365 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3366 }
3367 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3368 wxPyUserData* data = NULL;
3369 if ( userData ) {
3370 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3371 data = new wxPyUserData(userData);
3372 wxPyEndBlockThreads(blocked);
3373 }
3374 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3375 }
3376 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3377 int row, col;
3378 self->GetEndPos(row, col);
3379 return wxGBPosition(row, col);
3380 }
3381 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3382
3383 wxPyUserData* data = NULL;
3384 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3385 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3386 if ( userData && (info.window || info.sizer || info.gotSize) )
3387 data = new wxPyUserData(userData);
3388 if ( info.sizer )
3389 PyObject_SetAttrString(item,"thisown",Py_False);
3390 wxPyEndBlockThreads(blocked);
3391
3392 // Now call the real Add method if a valid item type was found
3393 if ( info.window )
3394 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3395 else if ( info.sizer )
3396 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3397 else if (info.gotSize)
3398 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3399 pos, span, flag, border, data);
3400 return NULL;
3401 }
3402
3403
3404 #ifdef __cplusplus
3405 extern "C" {
3406 #endif
3407 static int _wrap_EmptyString_set(PyObject *) {
3408 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3409 return 1;
3410 }
3411
3412
3413 static PyObject *_wrap_EmptyString_get(void) {
3414 PyObject *pyobj = NULL;
3415
3416 {
3417 #if wxUSE_UNICODE
3418 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3419 #else
3420 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3421 #endif
3422 }
3423 return pyobj;
3424 }
3425
3426
3427 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3428 PyObject *resultobj = NULL;
3429 wxObject *arg1 = (wxObject *) 0 ;
3430 wxString result;
3431 PyObject * obj0 = 0 ;
3432 char *kwnames[] = {
3433 (char *) "self", NULL
3434 };
3435
3436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3438 if (SWIG_arg_fail(1)) SWIG_fail;
3439 {
3440 PyThreadState* __tstate = wxPyBeginAllowThreads();
3441 result = wxObject_GetClassName(arg1);
3442
3443 wxPyEndAllowThreads(__tstate);
3444 if (PyErr_Occurred()) SWIG_fail;
3445 }
3446 {
3447 #if wxUSE_UNICODE
3448 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3449 #else
3450 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3451 #endif
3452 }
3453 return resultobj;
3454 fail:
3455 return NULL;
3456 }
3457
3458
3459 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3460 PyObject *resultobj = NULL;
3461 wxObject *arg1 = (wxObject *) 0 ;
3462 PyObject * obj0 = 0 ;
3463 char *kwnames[] = {
3464 (char *) "self", NULL
3465 };
3466
3467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3469 if (SWIG_arg_fail(1)) SWIG_fail;
3470 {
3471 PyThreadState* __tstate = wxPyBeginAllowThreads();
3472 wxObject_Destroy(arg1);
3473
3474 wxPyEndAllowThreads(__tstate);
3475 if (PyErr_Occurred()) SWIG_fail;
3476 }
3477 Py_INCREF(Py_None); resultobj = Py_None;
3478 return resultobj;
3479 fail:
3480 return NULL;
3481 }
3482
3483
3484 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3485 PyObject *obj;
3486 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3487 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3488 Py_INCREF(obj);
3489 return Py_BuildValue((char *)"");
3490 }
3491 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3492 PyObject *resultobj = NULL;
3493 wxSize *arg1 = (wxSize *) 0 ;
3494 int arg2 ;
3495 PyObject * obj0 = 0 ;
3496 PyObject * obj1 = 0 ;
3497 char *kwnames[] = {
3498 (char *) "self",(char *) "x", NULL
3499 };
3500
3501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3503 if (SWIG_arg_fail(1)) SWIG_fail;
3504 {
3505 arg2 = static_cast<int >(SWIG_As_int(obj1));
3506 if (SWIG_arg_fail(2)) SWIG_fail;
3507 }
3508 if (arg1) (arg1)->x = arg2;
3509
3510 Py_INCREF(Py_None); resultobj = Py_None;
3511 return resultobj;
3512 fail:
3513 return NULL;
3514 }
3515
3516
3517 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3518 PyObject *resultobj = NULL;
3519 wxSize *arg1 = (wxSize *) 0 ;
3520 int result;
3521 PyObject * obj0 = 0 ;
3522 char *kwnames[] = {
3523 (char *) "self", NULL
3524 };
3525
3526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3528 if (SWIG_arg_fail(1)) SWIG_fail;
3529 result = (int) ((arg1)->x);
3530
3531 {
3532 resultobj = SWIG_From_int(static_cast<int >(result));
3533 }
3534 return resultobj;
3535 fail:
3536 return NULL;
3537 }
3538
3539
3540 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3541 PyObject *resultobj = NULL;
3542 wxSize *arg1 = (wxSize *) 0 ;
3543 int arg2 ;
3544 PyObject * obj0 = 0 ;
3545 PyObject * obj1 = 0 ;
3546 char *kwnames[] = {
3547 (char *) "self",(char *) "y", NULL
3548 };
3549
3550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3552 if (SWIG_arg_fail(1)) SWIG_fail;
3553 {
3554 arg2 = static_cast<int >(SWIG_As_int(obj1));
3555 if (SWIG_arg_fail(2)) SWIG_fail;
3556 }
3557 if (arg1) (arg1)->y = arg2;
3558
3559 Py_INCREF(Py_None); resultobj = Py_None;
3560 return resultobj;
3561 fail:
3562 return NULL;
3563 }
3564
3565
3566 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3567 PyObject *resultobj = NULL;
3568 wxSize *arg1 = (wxSize *) 0 ;
3569 int result;
3570 PyObject * obj0 = 0 ;
3571 char *kwnames[] = {
3572 (char *) "self", NULL
3573 };
3574
3575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3577 if (SWIG_arg_fail(1)) SWIG_fail;
3578 result = (int) ((arg1)->y);
3579
3580 {
3581 resultobj = SWIG_From_int(static_cast<int >(result));
3582 }
3583 return resultobj;
3584 fail:
3585 return NULL;
3586 }
3587
3588
3589 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3590 PyObject *resultobj = NULL;
3591 int arg1 = (int) 0 ;
3592 int arg2 = (int) 0 ;
3593 wxSize *result;
3594 PyObject * obj0 = 0 ;
3595 PyObject * obj1 = 0 ;
3596 char *kwnames[] = {
3597 (char *) "w",(char *) "h", NULL
3598 };
3599
3600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3601 if (obj0) {
3602 {
3603 arg1 = static_cast<int >(SWIG_As_int(obj0));
3604 if (SWIG_arg_fail(1)) SWIG_fail;
3605 }
3606 }
3607 if (obj1) {
3608 {
3609 arg2 = static_cast<int >(SWIG_As_int(obj1));
3610 if (SWIG_arg_fail(2)) SWIG_fail;
3611 }
3612 }
3613 {
3614 PyThreadState* __tstate = wxPyBeginAllowThreads();
3615 result = (wxSize *)new wxSize(arg1,arg2);
3616
3617 wxPyEndAllowThreads(__tstate);
3618 if (PyErr_Occurred()) SWIG_fail;
3619 }
3620 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3621 return resultobj;
3622 fail:
3623 return NULL;
3624 }
3625
3626
3627 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3628 PyObject *resultobj = NULL;
3629 wxSize *arg1 = (wxSize *) 0 ;
3630 PyObject * obj0 = 0 ;
3631 char *kwnames[] = {
3632 (char *) "self", NULL
3633 };
3634
3635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3637 if (SWIG_arg_fail(1)) SWIG_fail;
3638 {
3639 PyThreadState* __tstate = wxPyBeginAllowThreads();
3640 delete arg1;
3641
3642 wxPyEndAllowThreads(__tstate);
3643 if (PyErr_Occurred()) SWIG_fail;
3644 }
3645 Py_INCREF(Py_None); resultobj = Py_None;
3646 return resultobj;
3647 fail:
3648 return NULL;
3649 }
3650
3651
3652 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3653 PyObject *resultobj = NULL;
3654 wxSize *arg1 = (wxSize *) 0 ;
3655 wxSize *arg2 = 0 ;
3656 bool result;
3657 wxSize temp2 ;
3658 PyObject * obj0 = 0 ;
3659 PyObject * obj1 = 0 ;
3660 char *kwnames[] = {
3661 (char *) "self",(char *) "sz", NULL
3662 };
3663
3664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3666 if (SWIG_arg_fail(1)) SWIG_fail;
3667 {
3668 arg2 = &temp2;
3669 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3670 }
3671 {
3672 PyThreadState* __tstate = wxPyBeginAllowThreads();
3673 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3674
3675 wxPyEndAllowThreads(__tstate);
3676 if (PyErr_Occurred()) SWIG_fail;
3677 }
3678 {
3679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3680 }
3681 return resultobj;
3682 fail:
3683 return NULL;
3684 }
3685
3686
3687 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3688 PyObject *resultobj = NULL;
3689 wxSize *arg1 = (wxSize *) 0 ;
3690 wxSize *arg2 = 0 ;
3691 bool result;
3692 wxSize temp2 ;
3693 PyObject * obj0 = 0 ;
3694 PyObject * obj1 = 0 ;
3695 char *kwnames[] = {
3696 (char *) "self",(char *) "sz", NULL
3697 };
3698
3699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3701 if (SWIG_arg_fail(1)) SWIG_fail;
3702 {
3703 arg2 = &temp2;
3704 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3705 }
3706 {
3707 PyThreadState* __tstate = wxPyBeginAllowThreads();
3708 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3709
3710 wxPyEndAllowThreads(__tstate);
3711 if (PyErr_Occurred()) SWIG_fail;
3712 }
3713 {
3714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3715 }
3716 return resultobj;
3717 fail:
3718 return NULL;
3719 }
3720
3721
3722 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3723 PyObject *resultobj = NULL;
3724 wxSize *arg1 = (wxSize *) 0 ;
3725 wxSize *arg2 = 0 ;
3726 wxSize result;
3727 wxSize temp2 ;
3728 PyObject * obj0 = 0 ;
3729 PyObject * obj1 = 0 ;
3730 char *kwnames[] = {
3731 (char *) "self",(char *) "sz", NULL
3732 };
3733
3734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3736 if (SWIG_arg_fail(1)) SWIG_fail;
3737 {
3738 arg2 = &temp2;
3739 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3740 }
3741 {
3742 PyThreadState* __tstate = wxPyBeginAllowThreads();
3743 result = (arg1)->operator +((wxSize const &)*arg2);
3744
3745 wxPyEndAllowThreads(__tstate);
3746 if (PyErr_Occurred()) SWIG_fail;
3747 }
3748 {
3749 wxSize * resultptr;
3750 resultptr = new wxSize(static_cast<wxSize & >(result));
3751 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3752 }
3753 return resultobj;
3754 fail:
3755 return NULL;
3756 }
3757
3758
3759 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3760 PyObject *resultobj = NULL;
3761 wxSize *arg1 = (wxSize *) 0 ;
3762 wxSize *arg2 = 0 ;
3763 wxSize result;
3764 wxSize temp2 ;
3765 PyObject * obj0 = 0 ;
3766 PyObject * obj1 = 0 ;
3767 char *kwnames[] = {
3768 (char *) "self",(char *) "sz", NULL
3769 };
3770
3771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3773 if (SWIG_arg_fail(1)) SWIG_fail;
3774 {
3775 arg2 = &temp2;
3776 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3777 }
3778 {
3779 PyThreadState* __tstate = wxPyBeginAllowThreads();
3780 result = (arg1)->operator -((wxSize const &)*arg2);
3781
3782 wxPyEndAllowThreads(__tstate);
3783 if (PyErr_Occurred()) SWIG_fail;
3784 }
3785 {
3786 wxSize * resultptr;
3787 resultptr = new wxSize(static_cast<wxSize & >(result));
3788 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3789 }
3790 return resultobj;
3791 fail:
3792 return NULL;
3793 }
3794
3795
3796 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3797 PyObject *resultobj = NULL;
3798 wxSize *arg1 = (wxSize *) 0 ;
3799 wxSize *arg2 = 0 ;
3800 wxSize temp2 ;
3801 PyObject * obj0 = 0 ;
3802 PyObject * obj1 = 0 ;
3803 char *kwnames[] = {
3804 (char *) "self",(char *) "sz", NULL
3805 };
3806
3807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3809 if (SWIG_arg_fail(1)) SWIG_fail;
3810 {
3811 arg2 = &temp2;
3812 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3813 }
3814 {
3815 PyThreadState* __tstate = wxPyBeginAllowThreads();
3816 (arg1)->IncTo((wxSize const &)*arg2);
3817
3818 wxPyEndAllowThreads(__tstate);
3819 if (PyErr_Occurred()) SWIG_fail;
3820 }
3821 Py_INCREF(Py_None); resultobj = Py_None;
3822 return resultobj;
3823 fail:
3824 return NULL;
3825 }
3826
3827
3828 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3829 PyObject *resultobj = NULL;
3830 wxSize *arg1 = (wxSize *) 0 ;
3831 wxSize *arg2 = 0 ;
3832 wxSize temp2 ;
3833 PyObject * obj0 = 0 ;
3834 PyObject * obj1 = 0 ;
3835 char *kwnames[] = {
3836 (char *) "self",(char *) "sz", NULL
3837 };
3838
3839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3841 if (SWIG_arg_fail(1)) SWIG_fail;
3842 {
3843 arg2 = &temp2;
3844 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3845 }
3846 {
3847 PyThreadState* __tstate = wxPyBeginAllowThreads();
3848 (arg1)->DecTo((wxSize const &)*arg2);
3849
3850 wxPyEndAllowThreads(__tstate);
3851 if (PyErr_Occurred()) SWIG_fail;
3852 }
3853 Py_INCREF(Py_None); resultobj = Py_None;
3854 return resultobj;
3855 fail:
3856 return NULL;
3857 }
3858
3859
3860 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3861 PyObject *resultobj = NULL;
3862 wxSize *arg1 = (wxSize *) 0 ;
3863 int arg2 ;
3864 int arg3 ;
3865 PyObject * obj0 = 0 ;
3866 PyObject * obj1 = 0 ;
3867 PyObject * obj2 = 0 ;
3868 char *kwnames[] = {
3869 (char *) "self",(char *) "w",(char *) "h", NULL
3870 };
3871
3872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3874 if (SWIG_arg_fail(1)) SWIG_fail;
3875 {
3876 arg2 = static_cast<int >(SWIG_As_int(obj1));
3877 if (SWIG_arg_fail(2)) SWIG_fail;
3878 }
3879 {
3880 arg3 = static_cast<int >(SWIG_As_int(obj2));
3881 if (SWIG_arg_fail(3)) SWIG_fail;
3882 }
3883 {
3884 PyThreadState* __tstate = wxPyBeginAllowThreads();
3885 (arg1)->Set(arg2,arg3);
3886
3887 wxPyEndAllowThreads(__tstate);
3888 if (PyErr_Occurred()) SWIG_fail;
3889 }
3890 Py_INCREF(Py_None); resultobj = Py_None;
3891 return resultobj;
3892 fail:
3893 return NULL;
3894 }
3895
3896
3897 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3898 PyObject *resultobj = NULL;
3899 wxSize *arg1 = (wxSize *) 0 ;
3900 int arg2 ;
3901 PyObject * obj0 = 0 ;
3902 PyObject * obj1 = 0 ;
3903 char *kwnames[] = {
3904 (char *) "self",(char *) "w", NULL
3905 };
3906
3907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3909 if (SWIG_arg_fail(1)) SWIG_fail;
3910 {
3911 arg2 = static_cast<int >(SWIG_As_int(obj1));
3912 if (SWIG_arg_fail(2)) SWIG_fail;
3913 }
3914 {
3915 PyThreadState* __tstate = wxPyBeginAllowThreads();
3916 (arg1)->SetWidth(arg2);
3917
3918 wxPyEndAllowThreads(__tstate);
3919 if (PyErr_Occurred()) SWIG_fail;
3920 }
3921 Py_INCREF(Py_None); resultobj = Py_None;
3922 return resultobj;
3923 fail:
3924 return NULL;
3925 }
3926
3927
3928 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3929 PyObject *resultobj = NULL;
3930 wxSize *arg1 = (wxSize *) 0 ;
3931 int arg2 ;
3932 PyObject * obj0 = 0 ;
3933 PyObject * obj1 = 0 ;
3934 char *kwnames[] = {
3935 (char *) "self",(char *) "h", NULL
3936 };
3937
3938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3940 if (SWIG_arg_fail(1)) SWIG_fail;
3941 {
3942 arg2 = static_cast<int >(SWIG_As_int(obj1));
3943 if (SWIG_arg_fail(2)) SWIG_fail;
3944 }
3945 {
3946 PyThreadState* __tstate = wxPyBeginAllowThreads();
3947 (arg1)->SetHeight(arg2);
3948
3949 wxPyEndAllowThreads(__tstate);
3950 if (PyErr_Occurred()) SWIG_fail;
3951 }
3952 Py_INCREF(Py_None); resultobj = Py_None;
3953 return resultobj;
3954 fail:
3955 return NULL;
3956 }
3957
3958
3959 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3960 PyObject *resultobj = NULL;
3961 wxSize *arg1 = (wxSize *) 0 ;
3962 int result;
3963 PyObject * obj0 = 0 ;
3964 char *kwnames[] = {
3965 (char *) "self", NULL
3966 };
3967
3968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3970 if (SWIG_arg_fail(1)) SWIG_fail;
3971 {
3972 PyThreadState* __tstate = wxPyBeginAllowThreads();
3973 result = (int)((wxSize const *)arg1)->GetWidth();
3974
3975 wxPyEndAllowThreads(__tstate);
3976 if (PyErr_Occurred()) SWIG_fail;
3977 }
3978 {
3979 resultobj = SWIG_From_int(static_cast<int >(result));
3980 }
3981 return resultobj;
3982 fail:
3983 return NULL;
3984 }
3985
3986
3987 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3988 PyObject *resultobj = NULL;
3989 wxSize *arg1 = (wxSize *) 0 ;
3990 int result;
3991 PyObject * obj0 = 0 ;
3992 char *kwnames[] = {
3993 (char *) "self", NULL
3994 };
3995
3996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3998 if (SWIG_arg_fail(1)) SWIG_fail;
3999 {
4000 PyThreadState* __tstate = wxPyBeginAllowThreads();
4001 result = (int)((wxSize const *)arg1)->GetHeight();
4002
4003 wxPyEndAllowThreads(__tstate);
4004 if (PyErr_Occurred()) SWIG_fail;
4005 }
4006 {
4007 resultobj = SWIG_From_int(static_cast<int >(result));
4008 }
4009 return resultobj;
4010 fail:
4011 return NULL;
4012 }
4013
4014
4015 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
4016 PyObject *resultobj = NULL;
4017 wxSize *arg1 = (wxSize *) 0 ;
4018 bool result;
4019 PyObject * obj0 = 0 ;
4020 char *kwnames[] = {
4021 (char *) "self", NULL
4022 };
4023
4024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
4025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4026 if (SWIG_arg_fail(1)) SWIG_fail;
4027 {
4028 PyThreadState* __tstate = wxPyBeginAllowThreads();
4029 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
4030
4031 wxPyEndAllowThreads(__tstate);
4032 if (PyErr_Occurred()) SWIG_fail;
4033 }
4034 {
4035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4036 }
4037 return resultobj;
4038 fail:
4039 return NULL;
4040 }
4041
4042
4043 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
4044 PyObject *resultobj = NULL;
4045 wxSize *arg1 = (wxSize *) 0 ;
4046 wxSize *arg2 = 0 ;
4047 wxSize temp2 ;
4048 PyObject * obj0 = 0 ;
4049 PyObject * obj1 = 0 ;
4050 char *kwnames[] = {
4051 (char *) "self",(char *) "size", NULL
4052 };
4053
4054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
4055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4056 if (SWIG_arg_fail(1)) SWIG_fail;
4057 {
4058 arg2 = &temp2;
4059 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4060 }
4061 {
4062 PyThreadState* __tstate = wxPyBeginAllowThreads();
4063 (arg1)->SetDefaults((wxSize const &)*arg2);
4064
4065 wxPyEndAllowThreads(__tstate);
4066 if (PyErr_Occurred()) SWIG_fail;
4067 }
4068 Py_INCREF(Py_None); resultobj = Py_None;
4069 return resultobj;
4070 fail:
4071 return NULL;
4072 }
4073
4074
4075 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4076 PyObject *resultobj = NULL;
4077 wxSize *arg1 = (wxSize *) 0 ;
4078 PyObject *result;
4079 PyObject * obj0 = 0 ;
4080 char *kwnames[] = {
4081 (char *) "self", NULL
4082 };
4083
4084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
4085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4086 if (SWIG_arg_fail(1)) SWIG_fail;
4087 {
4088 PyThreadState* __tstate = wxPyBeginAllowThreads();
4089 result = (PyObject *)wxSize_Get(arg1);
4090
4091 wxPyEndAllowThreads(__tstate);
4092 if (PyErr_Occurred()) SWIG_fail;
4093 }
4094 resultobj = result;
4095 return resultobj;
4096 fail:
4097 return NULL;
4098 }
4099
4100
4101 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
4102 PyObject *obj;
4103 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4104 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
4105 Py_INCREF(obj);
4106 return Py_BuildValue((char *)"");
4107 }
4108 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4109 PyObject *resultobj = NULL;
4110 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4111 double arg2 ;
4112 PyObject * obj0 = 0 ;
4113 PyObject * obj1 = 0 ;
4114 char *kwnames[] = {
4115 (char *) "self",(char *) "x", NULL
4116 };
4117
4118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
4119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4120 if (SWIG_arg_fail(1)) SWIG_fail;
4121 {
4122 arg2 = static_cast<double >(SWIG_As_double(obj1));
4123 if (SWIG_arg_fail(2)) SWIG_fail;
4124 }
4125 if (arg1) (arg1)->x = arg2;
4126
4127 Py_INCREF(Py_None); resultobj = Py_None;
4128 return resultobj;
4129 fail:
4130 return NULL;
4131 }
4132
4133
4134 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4135 PyObject *resultobj = NULL;
4136 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4137 double result;
4138 PyObject * obj0 = 0 ;
4139 char *kwnames[] = {
4140 (char *) "self", NULL
4141 };
4142
4143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
4144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4145 if (SWIG_arg_fail(1)) SWIG_fail;
4146 result = (double) ((arg1)->x);
4147
4148 {
4149 resultobj = SWIG_From_double(static_cast<double >(result));
4150 }
4151 return resultobj;
4152 fail:
4153 return NULL;
4154 }
4155
4156
4157 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4158 PyObject *resultobj = NULL;
4159 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4160 double arg2 ;
4161 PyObject * obj0 = 0 ;
4162 PyObject * obj1 = 0 ;
4163 char *kwnames[] = {
4164 (char *) "self",(char *) "y", NULL
4165 };
4166
4167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4169 if (SWIG_arg_fail(1)) SWIG_fail;
4170 {
4171 arg2 = static_cast<double >(SWIG_As_double(obj1));
4172 if (SWIG_arg_fail(2)) SWIG_fail;
4173 }
4174 if (arg1) (arg1)->y = arg2;
4175
4176 Py_INCREF(Py_None); resultobj = Py_None;
4177 return resultobj;
4178 fail:
4179 return NULL;
4180 }
4181
4182
4183 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4184 PyObject *resultobj = NULL;
4185 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4186 double result;
4187 PyObject * obj0 = 0 ;
4188 char *kwnames[] = {
4189 (char *) "self", NULL
4190 };
4191
4192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4194 if (SWIG_arg_fail(1)) SWIG_fail;
4195 result = (double) ((arg1)->y);
4196
4197 {
4198 resultobj = SWIG_From_double(static_cast<double >(result));
4199 }
4200 return resultobj;
4201 fail:
4202 return NULL;
4203 }
4204
4205
4206 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4207 PyObject *resultobj = NULL;
4208 double arg1 = (double) 0.0 ;
4209 double arg2 = (double) 0.0 ;
4210 wxRealPoint *result;
4211 PyObject * obj0 = 0 ;
4212 PyObject * obj1 = 0 ;
4213 char *kwnames[] = {
4214 (char *) "x",(char *) "y", NULL
4215 };
4216
4217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4218 if (obj0) {
4219 {
4220 arg1 = static_cast<double >(SWIG_As_double(obj0));
4221 if (SWIG_arg_fail(1)) SWIG_fail;
4222 }
4223 }
4224 if (obj1) {
4225 {
4226 arg2 = static_cast<double >(SWIG_As_double(obj1));
4227 if (SWIG_arg_fail(2)) SWIG_fail;
4228 }
4229 }
4230 {
4231 PyThreadState* __tstate = wxPyBeginAllowThreads();
4232 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4233
4234 wxPyEndAllowThreads(__tstate);
4235 if (PyErr_Occurred()) SWIG_fail;
4236 }
4237 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4238 return resultobj;
4239 fail:
4240 return NULL;
4241 }
4242
4243
4244 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4245 PyObject *resultobj = NULL;
4246 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4247 PyObject * obj0 = 0 ;
4248 char *kwnames[] = {
4249 (char *) "self", NULL
4250 };
4251
4252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4254 if (SWIG_arg_fail(1)) SWIG_fail;
4255 {
4256 PyThreadState* __tstate = wxPyBeginAllowThreads();
4257 delete arg1;
4258
4259 wxPyEndAllowThreads(__tstate);
4260 if (PyErr_Occurred()) SWIG_fail;
4261 }
4262 Py_INCREF(Py_None); resultobj = Py_None;
4263 return resultobj;
4264 fail:
4265 return NULL;
4266 }
4267
4268
4269 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4270 PyObject *resultobj = NULL;
4271 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4272 wxRealPoint *arg2 = 0 ;
4273 bool result;
4274 wxRealPoint temp2 ;
4275 PyObject * obj0 = 0 ;
4276 PyObject * obj1 = 0 ;
4277 char *kwnames[] = {
4278 (char *) "self",(char *) "pt", NULL
4279 };
4280
4281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4283 if (SWIG_arg_fail(1)) SWIG_fail;
4284 {
4285 arg2 = &temp2;
4286 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4287 }
4288 {
4289 PyThreadState* __tstate = wxPyBeginAllowThreads();
4290 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4291
4292 wxPyEndAllowThreads(__tstate);
4293 if (PyErr_Occurred()) SWIG_fail;
4294 }
4295 {
4296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4297 }
4298 return resultobj;
4299 fail:
4300 return NULL;
4301 }
4302
4303
4304 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4305 PyObject *resultobj = NULL;
4306 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4307 wxRealPoint *arg2 = 0 ;
4308 bool result;
4309 wxRealPoint temp2 ;
4310 PyObject * obj0 = 0 ;
4311 PyObject * obj1 = 0 ;
4312 char *kwnames[] = {
4313 (char *) "self",(char *) "pt", NULL
4314 };
4315
4316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4318 if (SWIG_arg_fail(1)) SWIG_fail;
4319 {
4320 arg2 = &temp2;
4321 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4322 }
4323 {
4324 PyThreadState* __tstate = wxPyBeginAllowThreads();
4325 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4326
4327 wxPyEndAllowThreads(__tstate);
4328 if (PyErr_Occurred()) SWIG_fail;
4329 }
4330 {
4331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4332 }
4333 return resultobj;
4334 fail:
4335 return NULL;
4336 }
4337
4338
4339 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4340 PyObject *resultobj = NULL;
4341 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4342 wxRealPoint *arg2 = 0 ;
4343 wxRealPoint result;
4344 wxRealPoint temp2 ;
4345 PyObject * obj0 = 0 ;
4346 PyObject * obj1 = 0 ;
4347 char *kwnames[] = {
4348 (char *) "self",(char *) "pt", NULL
4349 };
4350
4351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4353 if (SWIG_arg_fail(1)) SWIG_fail;
4354 {
4355 arg2 = &temp2;
4356 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4357 }
4358 {
4359 PyThreadState* __tstate = wxPyBeginAllowThreads();
4360 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4361
4362 wxPyEndAllowThreads(__tstate);
4363 if (PyErr_Occurred()) SWIG_fail;
4364 }
4365 {
4366 wxRealPoint * resultptr;
4367 resultptr = new wxRealPoint(static_cast<wxRealPoint & >(result));
4368 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4369 }
4370 return resultobj;
4371 fail:
4372 return NULL;
4373 }
4374
4375
4376 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4377 PyObject *resultobj = NULL;
4378 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4379 wxRealPoint *arg2 = 0 ;
4380 wxRealPoint result;
4381 wxRealPoint temp2 ;
4382 PyObject * obj0 = 0 ;
4383 PyObject * obj1 = 0 ;
4384 char *kwnames[] = {
4385 (char *) "self",(char *) "pt", NULL
4386 };
4387
4388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4390 if (SWIG_arg_fail(1)) SWIG_fail;
4391 {
4392 arg2 = &temp2;
4393 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4394 }
4395 {
4396 PyThreadState* __tstate = wxPyBeginAllowThreads();
4397 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4398
4399 wxPyEndAllowThreads(__tstate);
4400 if (PyErr_Occurred()) SWIG_fail;
4401 }
4402 {
4403 wxRealPoint * resultptr;
4404 resultptr = new wxRealPoint(static_cast<wxRealPoint & >(result));
4405 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4406 }
4407 return resultobj;
4408 fail:
4409 return NULL;
4410 }
4411
4412
4413 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4414 PyObject *resultobj = NULL;
4415 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4416 double arg2 ;
4417 double arg3 ;
4418 PyObject * obj0 = 0 ;
4419 PyObject * obj1 = 0 ;
4420 PyObject * obj2 = 0 ;
4421 char *kwnames[] = {
4422 (char *) "self",(char *) "x",(char *) "y", NULL
4423 };
4424
4425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4427 if (SWIG_arg_fail(1)) SWIG_fail;
4428 {
4429 arg2 = static_cast<double >(SWIG_As_double(obj1));
4430 if (SWIG_arg_fail(2)) SWIG_fail;
4431 }
4432 {
4433 arg3 = static_cast<double >(SWIG_As_double(obj2));
4434 if (SWIG_arg_fail(3)) SWIG_fail;
4435 }
4436 {
4437 PyThreadState* __tstate = wxPyBeginAllowThreads();
4438 wxRealPoint_Set(arg1,arg2,arg3);
4439
4440 wxPyEndAllowThreads(__tstate);
4441 if (PyErr_Occurred()) SWIG_fail;
4442 }
4443 Py_INCREF(Py_None); resultobj = Py_None;
4444 return resultobj;
4445 fail:
4446 return NULL;
4447 }
4448
4449
4450 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4451 PyObject *resultobj = NULL;
4452 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4453 PyObject *result;
4454 PyObject * obj0 = 0 ;
4455 char *kwnames[] = {
4456 (char *) "self", NULL
4457 };
4458
4459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4461 if (SWIG_arg_fail(1)) SWIG_fail;
4462 {
4463 PyThreadState* __tstate = wxPyBeginAllowThreads();
4464 result = (PyObject *)wxRealPoint_Get(arg1);
4465
4466 wxPyEndAllowThreads(__tstate);
4467 if (PyErr_Occurred()) SWIG_fail;
4468 }
4469 resultobj = result;
4470 return resultobj;
4471 fail:
4472 return NULL;
4473 }
4474
4475
4476 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4477 PyObject *obj;
4478 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4479 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4480 Py_INCREF(obj);
4481 return Py_BuildValue((char *)"");
4482 }
4483 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4484 PyObject *resultobj = NULL;
4485 wxPoint *arg1 = (wxPoint *) 0 ;
4486 int arg2 ;
4487 PyObject * obj0 = 0 ;
4488 PyObject * obj1 = 0 ;
4489 char *kwnames[] = {
4490 (char *) "self",(char *) "x", NULL
4491 };
4492
4493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4495 if (SWIG_arg_fail(1)) SWIG_fail;
4496 {
4497 arg2 = static_cast<int >(SWIG_As_int(obj1));
4498 if (SWIG_arg_fail(2)) SWIG_fail;
4499 }
4500 if (arg1) (arg1)->x = arg2;
4501
4502 Py_INCREF(Py_None); resultobj = Py_None;
4503 return resultobj;
4504 fail:
4505 return NULL;
4506 }
4507
4508
4509 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4510 PyObject *resultobj = NULL;
4511 wxPoint *arg1 = (wxPoint *) 0 ;
4512 int result;
4513 PyObject * obj0 = 0 ;
4514 char *kwnames[] = {
4515 (char *) "self", NULL
4516 };
4517
4518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4520 if (SWIG_arg_fail(1)) SWIG_fail;
4521 result = (int) ((arg1)->x);
4522
4523 {
4524 resultobj = SWIG_From_int(static_cast<int >(result));
4525 }
4526 return resultobj;
4527 fail:
4528 return NULL;
4529 }
4530
4531
4532 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4533 PyObject *resultobj = NULL;
4534 wxPoint *arg1 = (wxPoint *) 0 ;
4535 int arg2 ;
4536 PyObject * obj0 = 0 ;
4537 PyObject * obj1 = 0 ;
4538 char *kwnames[] = {
4539 (char *) "self",(char *) "y", NULL
4540 };
4541
4542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4544 if (SWIG_arg_fail(1)) SWIG_fail;
4545 {
4546 arg2 = static_cast<int >(SWIG_As_int(obj1));
4547 if (SWIG_arg_fail(2)) SWIG_fail;
4548 }
4549 if (arg1) (arg1)->y = arg2;
4550
4551 Py_INCREF(Py_None); resultobj = Py_None;
4552 return resultobj;
4553 fail:
4554 return NULL;
4555 }
4556
4557
4558 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4559 PyObject *resultobj = NULL;
4560 wxPoint *arg1 = (wxPoint *) 0 ;
4561 int result;
4562 PyObject * obj0 = 0 ;
4563 char *kwnames[] = {
4564 (char *) "self", NULL
4565 };
4566
4567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4569 if (SWIG_arg_fail(1)) SWIG_fail;
4570 result = (int) ((arg1)->y);
4571
4572 {
4573 resultobj = SWIG_From_int(static_cast<int >(result));
4574 }
4575 return resultobj;
4576 fail:
4577 return NULL;
4578 }
4579
4580
4581 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4582 PyObject *resultobj = NULL;
4583 int arg1 = (int) 0 ;
4584 int arg2 = (int) 0 ;
4585 wxPoint *result;
4586 PyObject * obj0 = 0 ;
4587 PyObject * obj1 = 0 ;
4588 char *kwnames[] = {
4589 (char *) "x",(char *) "y", NULL
4590 };
4591
4592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4593 if (obj0) {
4594 {
4595 arg1 = static_cast<int >(SWIG_As_int(obj0));
4596 if (SWIG_arg_fail(1)) SWIG_fail;
4597 }
4598 }
4599 if (obj1) {
4600 {
4601 arg2 = static_cast<int >(SWIG_As_int(obj1));
4602 if (SWIG_arg_fail(2)) SWIG_fail;
4603 }
4604 }
4605 {
4606 PyThreadState* __tstate = wxPyBeginAllowThreads();
4607 result = (wxPoint *)new wxPoint(arg1,arg2);
4608
4609 wxPyEndAllowThreads(__tstate);
4610 if (PyErr_Occurred()) SWIG_fail;
4611 }
4612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4613 return resultobj;
4614 fail:
4615 return NULL;
4616 }
4617
4618
4619 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4620 PyObject *resultobj = NULL;
4621 wxPoint *arg1 = (wxPoint *) 0 ;
4622 PyObject * obj0 = 0 ;
4623 char *kwnames[] = {
4624 (char *) "self", NULL
4625 };
4626
4627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4629 if (SWIG_arg_fail(1)) SWIG_fail;
4630 {
4631 PyThreadState* __tstate = wxPyBeginAllowThreads();
4632 delete arg1;
4633
4634 wxPyEndAllowThreads(__tstate);
4635 if (PyErr_Occurred()) SWIG_fail;
4636 }
4637 Py_INCREF(Py_None); resultobj = Py_None;
4638 return resultobj;
4639 fail:
4640 return NULL;
4641 }
4642
4643
4644 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4645 PyObject *resultobj = NULL;
4646 wxPoint *arg1 = (wxPoint *) 0 ;
4647 wxPoint *arg2 = 0 ;
4648 bool result;
4649 wxPoint temp2 ;
4650 PyObject * obj0 = 0 ;
4651 PyObject * obj1 = 0 ;
4652 char *kwnames[] = {
4653 (char *) "self",(char *) "pt", NULL
4654 };
4655
4656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4658 if (SWIG_arg_fail(1)) SWIG_fail;
4659 {
4660 arg2 = &temp2;
4661 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4662 }
4663 {
4664 PyThreadState* __tstate = wxPyBeginAllowThreads();
4665 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4666
4667 wxPyEndAllowThreads(__tstate);
4668 if (PyErr_Occurred()) SWIG_fail;
4669 }
4670 {
4671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4672 }
4673 return resultobj;
4674 fail:
4675 return NULL;
4676 }
4677
4678
4679 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4680 PyObject *resultobj = NULL;
4681 wxPoint *arg1 = (wxPoint *) 0 ;
4682 wxPoint *arg2 = 0 ;
4683 bool result;
4684 wxPoint temp2 ;
4685 PyObject * obj0 = 0 ;
4686 PyObject * obj1 = 0 ;
4687 char *kwnames[] = {
4688 (char *) "self",(char *) "pt", NULL
4689 };
4690
4691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4693 if (SWIG_arg_fail(1)) SWIG_fail;
4694 {
4695 arg2 = &temp2;
4696 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4697 }
4698 {
4699 PyThreadState* __tstate = wxPyBeginAllowThreads();
4700 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4701
4702 wxPyEndAllowThreads(__tstate);
4703 if (PyErr_Occurred()) SWIG_fail;
4704 }
4705 {
4706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4707 }
4708 return resultobj;
4709 fail:
4710 return NULL;
4711 }
4712
4713
4714 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4715 PyObject *resultobj = NULL;
4716 wxPoint *arg1 = (wxPoint *) 0 ;
4717 wxPoint *arg2 = 0 ;
4718 wxPoint result;
4719 wxPoint temp2 ;
4720 PyObject * obj0 = 0 ;
4721 PyObject * obj1 = 0 ;
4722 char *kwnames[] = {
4723 (char *) "self",(char *) "pt", NULL
4724 };
4725
4726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4728 if (SWIG_arg_fail(1)) SWIG_fail;
4729 {
4730 arg2 = &temp2;
4731 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4732 }
4733 {
4734 PyThreadState* __tstate = wxPyBeginAllowThreads();
4735 result = (arg1)->operator +((wxPoint const &)*arg2);
4736
4737 wxPyEndAllowThreads(__tstate);
4738 if (PyErr_Occurred()) SWIG_fail;
4739 }
4740 {
4741 wxPoint * resultptr;
4742 resultptr = new wxPoint(static_cast<wxPoint & >(result));
4743 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4744 }
4745 return resultobj;
4746 fail:
4747 return NULL;
4748 }
4749
4750
4751 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4752 PyObject *resultobj = NULL;
4753 wxPoint *arg1 = (wxPoint *) 0 ;
4754 wxPoint *arg2 = 0 ;
4755 wxPoint result;
4756 wxPoint temp2 ;
4757 PyObject * obj0 = 0 ;
4758 PyObject * obj1 = 0 ;
4759 char *kwnames[] = {
4760 (char *) "self",(char *) "pt", NULL
4761 };
4762
4763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4765 if (SWIG_arg_fail(1)) SWIG_fail;
4766 {
4767 arg2 = &temp2;
4768 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4769 }
4770 {
4771 PyThreadState* __tstate = wxPyBeginAllowThreads();
4772 result = (arg1)->operator -((wxPoint const &)*arg2);
4773
4774 wxPyEndAllowThreads(__tstate);
4775 if (PyErr_Occurred()) SWIG_fail;
4776 }
4777 {
4778 wxPoint * resultptr;
4779 resultptr = new wxPoint(static_cast<wxPoint & >(result));
4780 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4781 }
4782 return resultobj;
4783 fail:
4784 return NULL;
4785 }
4786
4787
4788 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4789 PyObject *resultobj = NULL;
4790 wxPoint *arg1 = (wxPoint *) 0 ;
4791 wxPoint *arg2 = 0 ;
4792 wxPoint *result;
4793 wxPoint temp2 ;
4794 PyObject * obj0 = 0 ;
4795 PyObject * obj1 = 0 ;
4796 char *kwnames[] = {
4797 (char *) "self",(char *) "pt", NULL
4798 };
4799
4800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4802 if (SWIG_arg_fail(1)) SWIG_fail;
4803 {
4804 arg2 = &temp2;
4805 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4806 }
4807 {
4808 PyThreadState* __tstate = wxPyBeginAllowThreads();
4809 {
4810 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4811 result = (wxPoint *) &_result_ref;
4812 }
4813
4814 wxPyEndAllowThreads(__tstate);
4815 if (PyErr_Occurred()) SWIG_fail;
4816 }
4817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4818 return resultobj;
4819 fail:
4820 return NULL;
4821 }
4822
4823
4824 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4825 PyObject *resultobj = NULL;
4826 wxPoint *arg1 = (wxPoint *) 0 ;
4827 wxPoint *arg2 = 0 ;
4828 wxPoint *result;
4829 wxPoint temp2 ;
4830 PyObject * obj0 = 0 ;
4831 PyObject * obj1 = 0 ;
4832 char *kwnames[] = {
4833 (char *) "self",(char *) "pt", NULL
4834 };
4835
4836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4838 if (SWIG_arg_fail(1)) SWIG_fail;
4839 {
4840 arg2 = &temp2;
4841 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4842 }
4843 {
4844 PyThreadState* __tstate = wxPyBeginAllowThreads();
4845 {
4846 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4847 result = (wxPoint *) &_result_ref;
4848 }
4849
4850 wxPyEndAllowThreads(__tstate);
4851 if (PyErr_Occurred()) SWIG_fail;
4852 }
4853 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4854 return resultobj;
4855 fail:
4856 return NULL;
4857 }
4858
4859
4860 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4861 PyObject *resultobj = NULL;
4862 wxPoint *arg1 = (wxPoint *) 0 ;
4863 long arg2 ;
4864 long arg3 ;
4865 PyObject * obj0 = 0 ;
4866 PyObject * obj1 = 0 ;
4867 PyObject * obj2 = 0 ;
4868 char *kwnames[] = {
4869 (char *) "self",(char *) "x",(char *) "y", NULL
4870 };
4871
4872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4874 if (SWIG_arg_fail(1)) SWIG_fail;
4875 {
4876 arg2 = static_cast<long >(SWIG_As_long(obj1));
4877 if (SWIG_arg_fail(2)) SWIG_fail;
4878 }
4879 {
4880 arg3 = static_cast<long >(SWIG_As_long(obj2));
4881 if (SWIG_arg_fail(3)) SWIG_fail;
4882 }
4883 {
4884 PyThreadState* __tstate = wxPyBeginAllowThreads();
4885 wxPoint_Set(arg1,arg2,arg3);
4886
4887 wxPyEndAllowThreads(__tstate);
4888 if (PyErr_Occurred()) SWIG_fail;
4889 }
4890 Py_INCREF(Py_None); resultobj = Py_None;
4891 return resultobj;
4892 fail:
4893 return NULL;
4894 }
4895
4896
4897 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4898 PyObject *resultobj = NULL;
4899 wxPoint *arg1 = (wxPoint *) 0 ;
4900 PyObject *result;
4901 PyObject * obj0 = 0 ;
4902 char *kwnames[] = {
4903 (char *) "self", NULL
4904 };
4905
4906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4908 if (SWIG_arg_fail(1)) SWIG_fail;
4909 {
4910 PyThreadState* __tstate = wxPyBeginAllowThreads();
4911 result = (PyObject *)wxPoint_Get(arg1);
4912
4913 wxPyEndAllowThreads(__tstate);
4914 if (PyErr_Occurred()) SWIG_fail;
4915 }
4916 resultobj = result;
4917 return resultobj;
4918 fail:
4919 return NULL;
4920 }
4921
4922
4923 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4924 PyObject *obj;
4925 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4926 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4927 Py_INCREF(obj);
4928 return Py_BuildValue((char *)"");
4929 }
4930 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4931 PyObject *resultobj = NULL;
4932 int arg1 = (int) 0 ;
4933 int arg2 = (int) 0 ;
4934 int arg3 = (int) 0 ;
4935 int arg4 = (int) 0 ;
4936 wxRect *result;
4937 PyObject * obj0 = 0 ;
4938 PyObject * obj1 = 0 ;
4939 PyObject * obj2 = 0 ;
4940 PyObject * obj3 = 0 ;
4941 char *kwnames[] = {
4942 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4943 };
4944
4945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4946 if (obj0) {
4947 {
4948 arg1 = static_cast<int >(SWIG_As_int(obj0));
4949 if (SWIG_arg_fail(1)) SWIG_fail;
4950 }
4951 }
4952 if (obj1) {
4953 {
4954 arg2 = static_cast<int >(SWIG_As_int(obj1));
4955 if (SWIG_arg_fail(2)) SWIG_fail;
4956 }
4957 }
4958 if (obj2) {
4959 {
4960 arg3 = static_cast<int >(SWIG_As_int(obj2));
4961 if (SWIG_arg_fail(3)) SWIG_fail;
4962 }
4963 }
4964 if (obj3) {
4965 {
4966 arg4 = static_cast<int >(SWIG_As_int(obj3));
4967 if (SWIG_arg_fail(4)) SWIG_fail;
4968 }
4969 }
4970 {
4971 PyThreadState* __tstate = wxPyBeginAllowThreads();
4972 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4973
4974 wxPyEndAllowThreads(__tstate);
4975 if (PyErr_Occurred()) SWIG_fail;
4976 }
4977 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4978 return resultobj;
4979 fail:
4980 return NULL;
4981 }
4982
4983
4984 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4985 PyObject *resultobj = NULL;
4986 wxPoint *arg1 = 0 ;
4987 wxPoint *arg2 = 0 ;
4988 wxRect *result;
4989 wxPoint temp1 ;
4990 wxPoint temp2 ;
4991 PyObject * obj0 = 0 ;
4992 PyObject * obj1 = 0 ;
4993 char *kwnames[] = {
4994 (char *) "topLeft",(char *) "bottomRight", NULL
4995 };
4996
4997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4998 {
4999 arg1 = &temp1;
5000 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5001 }
5002 {
5003 arg2 = &temp2;
5004 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5005 }
5006 {
5007 PyThreadState* __tstate = wxPyBeginAllowThreads();
5008 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
5009
5010 wxPyEndAllowThreads(__tstate);
5011 if (PyErr_Occurred()) SWIG_fail;
5012 }
5013 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5014 return resultobj;
5015 fail:
5016 return NULL;
5017 }
5018
5019
5020 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
5021 PyObject *resultobj = NULL;
5022 wxPoint *arg1 = 0 ;
5023 wxSize *arg2 = 0 ;
5024 wxRect *result;
5025 wxPoint temp1 ;
5026 wxSize temp2 ;
5027 PyObject * obj0 = 0 ;
5028 PyObject * obj1 = 0 ;
5029 char *kwnames[] = {
5030 (char *) "pos",(char *) "size", NULL
5031 };
5032
5033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
5034 {
5035 arg1 = &temp1;
5036 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5037 }
5038 {
5039 arg2 = &temp2;
5040 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5041 }
5042 {
5043 PyThreadState* __tstate = wxPyBeginAllowThreads();
5044 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
5045
5046 wxPyEndAllowThreads(__tstate);
5047 if (PyErr_Occurred()) SWIG_fail;
5048 }
5049 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5050 return resultobj;
5051 fail:
5052 return NULL;
5053 }
5054
5055
5056 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
5057 PyObject *resultobj = NULL;
5058 wxSize *arg1 = 0 ;
5059 wxRect *result;
5060 wxSize temp1 ;
5061 PyObject * obj0 = 0 ;
5062 char *kwnames[] = {
5063 (char *) "size", NULL
5064 };
5065
5066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
5067 {
5068 arg1 = &temp1;
5069 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
5070 }
5071 {
5072 PyThreadState* __tstate = wxPyBeginAllowThreads();
5073 result = (wxRect *)new wxRect((wxSize const &)*arg1);
5074
5075 wxPyEndAllowThreads(__tstate);
5076 if (PyErr_Occurred()) SWIG_fail;
5077 }
5078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5079 return resultobj;
5080 fail:
5081 return NULL;
5082 }
5083
5084
5085 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
5086 PyObject *resultobj = NULL;
5087 wxRect *arg1 = (wxRect *) 0 ;
5088 PyObject * obj0 = 0 ;
5089 char *kwnames[] = {
5090 (char *) "self", NULL
5091 };
5092
5093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
5094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5095 if (SWIG_arg_fail(1)) SWIG_fail;
5096 {
5097 PyThreadState* __tstate = wxPyBeginAllowThreads();
5098 delete arg1;
5099
5100 wxPyEndAllowThreads(__tstate);
5101 if (PyErr_Occurred()) SWIG_fail;
5102 }
5103 Py_INCREF(Py_None); resultobj = Py_None;
5104 return resultobj;
5105 fail:
5106 return NULL;
5107 }
5108
5109
5110 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
5111 PyObject *resultobj = NULL;
5112 wxRect *arg1 = (wxRect *) 0 ;
5113 int result;
5114 PyObject * obj0 = 0 ;
5115 char *kwnames[] = {
5116 (char *) "self", NULL
5117 };
5118
5119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
5120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5121 if (SWIG_arg_fail(1)) SWIG_fail;
5122 {
5123 PyThreadState* __tstate = wxPyBeginAllowThreads();
5124 result = (int)((wxRect const *)arg1)->GetX();
5125
5126 wxPyEndAllowThreads(__tstate);
5127 if (PyErr_Occurred()) SWIG_fail;
5128 }
5129 {
5130 resultobj = SWIG_From_int(static_cast<int >(result));
5131 }
5132 return resultobj;
5133 fail:
5134 return NULL;
5135 }
5136
5137
5138 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
5139 PyObject *resultobj = NULL;
5140 wxRect *arg1 = (wxRect *) 0 ;
5141 int arg2 ;
5142 PyObject * obj0 = 0 ;
5143 PyObject * obj1 = 0 ;
5144 char *kwnames[] = {
5145 (char *) "self",(char *) "x", NULL
5146 };
5147
5148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
5149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5150 if (SWIG_arg_fail(1)) SWIG_fail;
5151 {
5152 arg2 = static_cast<int >(SWIG_As_int(obj1));
5153 if (SWIG_arg_fail(2)) SWIG_fail;
5154 }
5155 {
5156 PyThreadState* __tstate = wxPyBeginAllowThreads();
5157 (arg1)->SetX(arg2);
5158
5159 wxPyEndAllowThreads(__tstate);
5160 if (PyErr_Occurred()) SWIG_fail;
5161 }
5162 Py_INCREF(Py_None); resultobj = Py_None;
5163 return resultobj;
5164 fail:
5165 return NULL;
5166 }
5167
5168
5169 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5170 PyObject *resultobj = NULL;
5171 wxRect *arg1 = (wxRect *) 0 ;
5172 int result;
5173 PyObject * obj0 = 0 ;
5174 char *kwnames[] = {
5175 (char *) "self", NULL
5176 };
5177
5178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5180 if (SWIG_arg_fail(1)) SWIG_fail;
5181 {
5182 PyThreadState* __tstate = wxPyBeginAllowThreads();
5183 result = (int)(arg1)->GetY();
5184
5185 wxPyEndAllowThreads(__tstate);
5186 if (PyErr_Occurred()) SWIG_fail;
5187 }
5188 {
5189 resultobj = SWIG_From_int(static_cast<int >(result));
5190 }
5191 return resultobj;
5192 fail:
5193 return NULL;
5194 }
5195
5196
5197 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5198 PyObject *resultobj = NULL;
5199 wxRect *arg1 = (wxRect *) 0 ;
5200 int arg2 ;
5201 PyObject * obj0 = 0 ;
5202 PyObject * obj1 = 0 ;
5203 char *kwnames[] = {
5204 (char *) "self",(char *) "y", NULL
5205 };
5206
5207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5209 if (SWIG_arg_fail(1)) SWIG_fail;
5210 {
5211 arg2 = static_cast<int >(SWIG_As_int(obj1));
5212 if (SWIG_arg_fail(2)) SWIG_fail;
5213 }
5214 {
5215 PyThreadState* __tstate = wxPyBeginAllowThreads();
5216 (arg1)->SetY(arg2);
5217
5218 wxPyEndAllowThreads(__tstate);
5219 if (PyErr_Occurred()) SWIG_fail;
5220 }
5221 Py_INCREF(Py_None); resultobj = Py_None;
5222 return resultobj;
5223 fail:
5224 return NULL;
5225 }
5226
5227
5228 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5229 PyObject *resultobj = NULL;
5230 wxRect *arg1 = (wxRect *) 0 ;
5231 int result;
5232 PyObject * obj0 = 0 ;
5233 char *kwnames[] = {
5234 (char *) "self", NULL
5235 };
5236
5237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5239 if (SWIG_arg_fail(1)) SWIG_fail;
5240 {
5241 PyThreadState* __tstate = wxPyBeginAllowThreads();
5242 result = (int)((wxRect const *)arg1)->GetWidth();
5243
5244 wxPyEndAllowThreads(__tstate);
5245 if (PyErr_Occurred()) SWIG_fail;
5246 }
5247 {
5248 resultobj = SWIG_From_int(static_cast<int >(result));
5249 }
5250 return resultobj;
5251 fail:
5252 return NULL;
5253 }
5254
5255
5256 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5257 PyObject *resultobj = NULL;
5258 wxRect *arg1 = (wxRect *) 0 ;
5259 int arg2 ;
5260 PyObject * obj0 = 0 ;
5261 PyObject * obj1 = 0 ;
5262 char *kwnames[] = {
5263 (char *) "self",(char *) "w", NULL
5264 };
5265
5266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5268 if (SWIG_arg_fail(1)) SWIG_fail;
5269 {
5270 arg2 = static_cast<int >(SWIG_As_int(obj1));
5271 if (SWIG_arg_fail(2)) SWIG_fail;
5272 }
5273 {
5274 PyThreadState* __tstate = wxPyBeginAllowThreads();
5275 (arg1)->SetWidth(arg2);
5276
5277 wxPyEndAllowThreads(__tstate);
5278 if (PyErr_Occurred()) SWIG_fail;
5279 }
5280 Py_INCREF(Py_None); resultobj = Py_None;
5281 return resultobj;
5282 fail:
5283 return NULL;
5284 }
5285
5286
5287 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5288 PyObject *resultobj = NULL;
5289 wxRect *arg1 = (wxRect *) 0 ;
5290 int result;
5291 PyObject * obj0 = 0 ;
5292 char *kwnames[] = {
5293 (char *) "self", NULL
5294 };
5295
5296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5298 if (SWIG_arg_fail(1)) SWIG_fail;
5299 {
5300 PyThreadState* __tstate = wxPyBeginAllowThreads();
5301 result = (int)((wxRect const *)arg1)->GetHeight();
5302
5303 wxPyEndAllowThreads(__tstate);
5304 if (PyErr_Occurred()) SWIG_fail;
5305 }
5306 {
5307 resultobj = SWIG_From_int(static_cast<int >(result));
5308 }
5309 return resultobj;
5310 fail:
5311 return NULL;
5312 }
5313
5314
5315 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5316 PyObject *resultobj = NULL;
5317 wxRect *arg1 = (wxRect *) 0 ;
5318 int arg2 ;
5319 PyObject * obj0 = 0 ;
5320 PyObject * obj1 = 0 ;
5321 char *kwnames[] = {
5322 (char *) "self",(char *) "h", NULL
5323 };
5324
5325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5327 if (SWIG_arg_fail(1)) SWIG_fail;
5328 {
5329 arg2 = static_cast<int >(SWIG_As_int(obj1));
5330 if (SWIG_arg_fail(2)) SWIG_fail;
5331 }
5332 {
5333 PyThreadState* __tstate = wxPyBeginAllowThreads();
5334 (arg1)->SetHeight(arg2);
5335
5336 wxPyEndAllowThreads(__tstate);
5337 if (PyErr_Occurred()) SWIG_fail;
5338 }
5339 Py_INCREF(Py_None); resultobj = Py_None;
5340 return resultobj;
5341 fail:
5342 return NULL;
5343 }
5344
5345
5346 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5347 PyObject *resultobj = NULL;
5348 wxRect *arg1 = (wxRect *) 0 ;
5349 wxPoint result;
5350 PyObject * obj0 = 0 ;
5351 char *kwnames[] = {
5352 (char *) "self", NULL
5353 };
5354
5355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5357 if (SWIG_arg_fail(1)) SWIG_fail;
5358 {
5359 PyThreadState* __tstate = wxPyBeginAllowThreads();
5360 result = ((wxRect const *)arg1)->GetPosition();
5361
5362 wxPyEndAllowThreads(__tstate);
5363 if (PyErr_Occurred()) SWIG_fail;
5364 }
5365 {
5366 wxPoint * resultptr;
5367 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5368 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5369 }
5370 return resultobj;
5371 fail:
5372 return NULL;
5373 }
5374
5375
5376 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5377 PyObject *resultobj = NULL;
5378 wxRect *arg1 = (wxRect *) 0 ;
5379 wxPoint *arg2 = 0 ;
5380 wxPoint temp2 ;
5381 PyObject * obj0 = 0 ;
5382 PyObject * obj1 = 0 ;
5383 char *kwnames[] = {
5384 (char *) "self",(char *) "p", NULL
5385 };
5386
5387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5389 if (SWIG_arg_fail(1)) SWIG_fail;
5390 {
5391 arg2 = &temp2;
5392 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5393 }
5394 {
5395 PyThreadState* __tstate = wxPyBeginAllowThreads();
5396 (arg1)->SetPosition((wxPoint const &)*arg2);
5397
5398 wxPyEndAllowThreads(__tstate);
5399 if (PyErr_Occurred()) SWIG_fail;
5400 }
5401 Py_INCREF(Py_None); resultobj = Py_None;
5402 return resultobj;
5403 fail:
5404 return NULL;
5405 }
5406
5407
5408 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5409 PyObject *resultobj = NULL;
5410 wxRect *arg1 = (wxRect *) 0 ;
5411 wxSize result;
5412 PyObject * obj0 = 0 ;
5413 char *kwnames[] = {
5414 (char *) "self", NULL
5415 };
5416
5417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5419 if (SWIG_arg_fail(1)) SWIG_fail;
5420 {
5421 PyThreadState* __tstate = wxPyBeginAllowThreads();
5422 result = ((wxRect const *)arg1)->GetSize();
5423
5424 wxPyEndAllowThreads(__tstate);
5425 if (PyErr_Occurred()) SWIG_fail;
5426 }
5427 {
5428 wxSize * resultptr;
5429 resultptr = new wxSize(static_cast<wxSize & >(result));
5430 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5431 }
5432 return resultobj;
5433 fail:
5434 return NULL;
5435 }
5436
5437
5438 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5439 PyObject *resultobj = NULL;
5440 wxRect *arg1 = (wxRect *) 0 ;
5441 wxSize *arg2 = 0 ;
5442 wxSize temp2 ;
5443 PyObject * obj0 = 0 ;
5444 PyObject * obj1 = 0 ;
5445 char *kwnames[] = {
5446 (char *) "self",(char *) "s", NULL
5447 };
5448
5449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5451 if (SWIG_arg_fail(1)) SWIG_fail;
5452 {
5453 arg2 = &temp2;
5454 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5455 }
5456 {
5457 PyThreadState* __tstate = wxPyBeginAllowThreads();
5458 (arg1)->SetSize((wxSize const &)*arg2);
5459
5460 wxPyEndAllowThreads(__tstate);
5461 if (PyErr_Occurred()) SWIG_fail;
5462 }
5463 Py_INCREF(Py_None); resultobj = Py_None;
5464 return resultobj;
5465 fail:
5466 return NULL;
5467 }
5468
5469
5470 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5471 PyObject *resultobj = NULL;
5472 wxRect *arg1 = (wxRect *) 0 ;
5473 bool result;
5474 PyObject * obj0 = 0 ;
5475 char *kwnames[] = {
5476 (char *) "self", NULL
5477 };
5478
5479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5481 if (SWIG_arg_fail(1)) SWIG_fail;
5482 {
5483 PyThreadState* __tstate = wxPyBeginAllowThreads();
5484 result = (bool)((wxRect const *)arg1)->IsEmpty();
5485
5486 wxPyEndAllowThreads(__tstate);
5487 if (PyErr_Occurred()) SWIG_fail;
5488 }
5489 {
5490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5491 }
5492 return resultobj;
5493 fail:
5494 return NULL;
5495 }
5496
5497
5498 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5499 PyObject *resultobj = NULL;
5500 wxRect *arg1 = (wxRect *) 0 ;
5501 wxPoint result;
5502 PyObject * obj0 = 0 ;
5503 char *kwnames[] = {
5504 (char *) "self", NULL
5505 };
5506
5507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5509 if (SWIG_arg_fail(1)) SWIG_fail;
5510 {
5511 PyThreadState* __tstate = wxPyBeginAllowThreads();
5512 result = ((wxRect const *)arg1)->GetTopLeft();
5513
5514 wxPyEndAllowThreads(__tstate);
5515 if (PyErr_Occurred()) SWIG_fail;
5516 }
5517 {
5518 wxPoint * resultptr;
5519 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5520 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5521 }
5522 return resultobj;
5523 fail:
5524 return NULL;
5525 }
5526
5527
5528 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5529 PyObject *resultobj = NULL;
5530 wxRect *arg1 = (wxRect *) 0 ;
5531 wxPoint *arg2 = 0 ;
5532 wxPoint temp2 ;
5533 PyObject * obj0 = 0 ;
5534 PyObject * obj1 = 0 ;
5535 char *kwnames[] = {
5536 (char *) "self",(char *) "p", NULL
5537 };
5538
5539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5541 if (SWIG_arg_fail(1)) SWIG_fail;
5542 {
5543 arg2 = &temp2;
5544 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5545 }
5546 {
5547 PyThreadState* __tstate = wxPyBeginAllowThreads();
5548 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5549
5550 wxPyEndAllowThreads(__tstate);
5551 if (PyErr_Occurred()) SWIG_fail;
5552 }
5553 Py_INCREF(Py_None); resultobj = Py_None;
5554 return resultobj;
5555 fail:
5556 return NULL;
5557 }
5558
5559
5560 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5561 PyObject *resultobj = NULL;
5562 wxRect *arg1 = (wxRect *) 0 ;
5563 wxPoint result;
5564 PyObject * obj0 = 0 ;
5565 char *kwnames[] = {
5566 (char *) "self", NULL
5567 };
5568
5569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5571 if (SWIG_arg_fail(1)) SWIG_fail;
5572 {
5573 PyThreadState* __tstate = wxPyBeginAllowThreads();
5574 result = ((wxRect const *)arg1)->GetBottomRight();
5575
5576 wxPyEndAllowThreads(__tstate);
5577 if (PyErr_Occurred()) SWIG_fail;
5578 }
5579 {
5580 wxPoint * resultptr;
5581 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5582 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5583 }
5584 return resultobj;
5585 fail:
5586 return NULL;
5587 }
5588
5589
5590 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5591 PyObject *resultobj = NULL;
5592 wxRect *arg1 = (wxRect *) 0 ;
5593 wxPoint *arg2 = 0 ;
5594 wxPoint temp2 ;
5595 PyObject * obj0 = 0 ;
5596 PyObject * obj1 = 0 ;
5597 char *kwnames[] = {
5598 (char *) "self",(char *) "p", NULL
5599 };
5600
5601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5603 if (SWIG_arg_fail(1)) SWIG_fail;
5604 {
5605 arg2 = &temp2;
5606 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5607 }
5608 {
5609 PyThreadState* __tstate = wxPyBeginAllowThreads();
5610 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5611
5612 wxPyEndAllowThreads(__tstate);
5613 if (PyErr_Occurred()) SWIG_fail;
5614 }
5615 Py_INCREF(Py_None); resultobj = Py_None;
5616 return resultobj;
5617 fail:
5618 return NULL;
5619 }
5620
5621
5622 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5623 PyObject *resultobj = NULL;
5624 wxRect *arg1 = (wxRect *) 0 ;
5625 int result;
5626 PyObject * obj0 = 0 ;
5627 char *kwnames[] = {
5628 (char *) "self", NULL
5629 };
5630
5631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5633 if (SWIG_arg_fail(1)) SWIG_fail;
5634 {
5635 PyThreadState* __tstate = wxPyBeginAllowThreads();
5636 result = (int)((wxRect const *)arg1)->GetLeft();
5637
5638 wxPyEndAllowThreads(__tstate);
5639 if (PyErr_Occurred()) SWIG_fail;
5640 }
5641 {
5642 resultobj = SWIG_From_int(static_cast<int >(result));
5643 }
5644 return resultobj;
5645 fail:
5646 return NULL;
5647 }
5648
5649
5650 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5651 PyObject *resultobj = NULL;
5652 wxRect *arg1 = (wxRect *) 0 ;
5653 int result;
5654 PyObject * obj0 = 0 ;
5655 char *kwnames[] = {
5656 (char *) "self", NULL
5657 };
5658
5659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5661 if (SWIG_arg_fail(1)) SWIG_fail;
5662 {
5663 PyThreadState* __tstate = wxPyBeginAllowThreads();
5664 result = (int)((wxRect const *)arg1)->GetTop();
5665
5666 wxPyEndAllowThreads(__tstate);
5667 if (PyErr_Occurred()) SWIG_fail;
5668 }
5669 {
5670 resultobj = SWIG_From_int(static_cast<int >(result));
5671 }
5672 return resultobj;
5673 fail:
5674 return NULL;
5675 }
5676
5677
5678 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5679 PyObject *resultobj = NULL;
5680 wxRect *arg1 = (wxRect *) 0 ;
5681 int result;
5682 PyObject * obj0 = 0 ;
5683 char *kwnames[] = {
5684 (char *) "self", NULL
5685 };
5686
5687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5689 if (SWIG_arg_fail(1)) SWIG_fail;
5690 {
5691 PyThreadState* __tstate = wxPyBeginAllowThreads();
5692 result = (int)((wxRect const *)arg1)->GetBottom();
5693
5694 wxPyEndAllowThreads(__tstate);
5695 if (PyErr_Occurred()) SWIG_fail;
5696 }
5697 {
5698 resultobj = SWIG_From_int(static_cast<int >(result));
5699 }
5700 return resultobj;
5701 fail:
5702 return NULL;
5703 }
5704
5705
5706 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5707 PyObject *resultobj = NULL;
5708 wxRect *arg1 = (wxRect *) 0 ;
5709 int result;
5710 PyObject * obj0 = 0 ;
5711 char *kwnames[] = {
5712 (char *) "self", NULL
5713 };
5714
5715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5717 if (SWIG_arg_fail(1)) SWIG_fail;
5718 {
5719 PyThreadState* __tstate = wxPyBeginAllowThreads();
5720 result = (int)((wxRect const *)arg1)->GetRight();
5721
5722 wxPyEndAllowThreads(__tstate);
5723 if (PyErr_Occurred()) SWIG_fail;
5724 }
5725 {
5726 resultobj = SWIG_From_int(static_cast<int >(result));
5727 }
5728 return resultobj;
5729 fail:
5730 return NULL;
5731 }
5732
5733
5734 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5735 PyObject *resultobj = NULL;
5736 wxRect *arg1 = (wxRect *) 0 ;
5737 int arg2 ;
5738 PyObject * obj0 = 0 ;
5739 PyObject * obj1 = 0 ;
5740 char *kwnames[] = {
5741 (char *) "self",(char *) "left", NULL
5742 };
5743
5744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5746 if (SWIG_arg_fail(1)) SWIG_fail;
5747 {
5748 arg2 = static_cast<int >(SWIG_As_int(obj1));
5749 if (SWIG_arg_fail(2)) SWIG_fail;
5750 }
5751 {
5752 PyThreadState* __tstate = wxPyBeginAllowThreads();
5753 (arg1)->SetLeft(arg2);
5754
5755 wxPyEndAllowThreads(__tstate);
5756 if (PyErr_Occurred()) SWIG_fail;
5757 }
5758 Py_INCREF(Py_None); resultobj = Py_None;
5759 return resultobj;
5760 fail:
5761 return NULL;
5762 }
5763
5764
5765 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5766 PyObject *resultobj = NULL;
5767 wxRect *arg1 = (wxRect *) 0 ;
5768 int arg2 ;
5769 PyObject * obj0 = 0 ;
5770 PyObject * obj1 = 0 ;
5771 char *kwnames[] = {
5772 (char *) "self",(char *) "right", NULL
5773 };
5774
5775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5777 if (SWIG_arg_fail(1)) SWIG_fail;
5778 {
5779 arg2 = static_cast<int >(SWIG_As_int(obj1));
5780 if (SWIG_arg_fail(2)) SWIG_fail;
5781 }
5782 {
5783 PyThreadState* __tstate = wxPyBeginAllowThreads();
5784 (arg1)->SetRight(arg2);
5785
5786 wxPyEndAllowThreads(__tstate);
5787 if (PyErr_Occurred()) SWIG_fail;
5788 }
5789 Py_INCREF(Py_None); resultobj = Py_None;
5790 return resultobj;
5791 fail:
5792 return NULL;
5793 }
5794
5795
5796 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5797 PyObject *resultobj = NULL;
5798 wxRect *arg1 = (wxRect *) 0 ;
5799 int arg2 ;
5800 PyObject * obj0 = 0 ;
5801 PyObject * obj1 = 0 ;
5802 char *kwnames[] = {
5803 (char *) "self",(char *) "top", NULL
5804 };
5805
5806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5808 if (SWIG_arg_fail(1)) SWIG_fail;
5809 {
5810 arg2 = static_cast<int >(SWIG_As_int(obj1));
5811 if (SWIG_arg_fail(2)) SWIG_fail;
5812 }
5813 {
5814 PyThreadState* __tstate = wxPyBeginAllowThreads();
5815 (arg1)->SetTop(arg2);
5816
5817 wxPyEndAllowThreads(__tstate);
5818 if (PyErr_Occurred()) SWIG_fail;
5819 }
5820 Py_INCREF(Py_None); resultobj = Py_None;
5821 return resultobj;
5822 fail:
5823 return NULL;
5824 }
5825
5826
5827 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5828 PyObject *resultobj = NULL;
5829 wxRect *arg1 = (wxRect *) 0 ;
5830 int arg2 ;
5831 PyObject * obj0 = 0 ;
5832 PyObject * obj1 = 0 ;
5833 char *kwnames[] = {
5834 (char *) "self",(char *) "bottom", NULL
5835 };
5836
5837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5839 if (SWIG_arg_fail(1)) SWIG_fail;
5840 {
5841 arg2 = static_cast<int >(SWIG_As_int(obj1));
5842 if (SWIG_arg_fail(2)) SWIG_fail;
5843 }
5844 {
5845 PyThreadState* __tstate = wxPyBeginAllowThreads();
5846 (arg1)->SetBottom(arg2);
5847
5848 wxPyEndAllowThreads(__tstate);
5849 if (PyErr_Occurred()) SWIG_fail;
5850 }
5851 Py_INCREF(Py_None); resultobj = Py_None;
5852 return resultobj;
5853 fail:
5854 return NULL;
5855 }
5856
5857
5858 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5859 PyObject *resultobj = NULL;
5860 wxRect *arg1 = (wxRect *) 0 ;
5861 int arg2 ;
5862 int arg3 ;
5863 wxRect *result;
5864 PyObject * obj0 = 0 ;
5865 PyObject * obj1 = 0 ;
5866 PyObject * obj2 = 0 ;
5867 char *kwnames[] = {
5868 (char *) "self",(char *) "dx",(char *) "dy", NULL
5869 };
5870
5871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5873 if (SWIG_arg_fail(1)) SWIG_fail;
5874 {
5875 arg2 = static_cast<int >(SWIG_As_int(obj1));
5876 if (SWIG_arg_fail(2)) SWIG_fail;
5877 }
5878 {
5879 arg3 = static_cast<int >(SWIG_As_int(obj2));
5880 if (SWIG_arg_fail(3)) SWIG_fail;
5881 }
5882 {
5883 PyThreadState* __tstate = wxPyBeginAllowThreads();
5884 {
5885 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5886 result = (wxRect *) &_result_ref;
5887 }
5888
5889 wxPyEndAllowThreads(__tstate);
5890 if (PyErr_Occurred()) SWIG_fail;
5891 }
5892 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5893 return resultobj;
5894 fail:
5895 return NULL;
5896 }
5897
5898
5899 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5900 PyObject *resultobj = NULL;
5901 wxRect *arg1 = (wxRect *) 0 ;
5902 int arg2 ;
5903 int arg3 ;
5904 wxRect *result;
5905 PyObject * obj0 = 0 ;
5906 PyObject * obj1 = 0 ;
5907 PyObject * obj2 = 0 ;
5908 char *kwnames[] = {
5909 (char *) "self",(char *) "dx",(char *) "dy", NULL
5910 };
5911
5912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5914 if (SWIG_arg_fail(1)) SWIG_fail;
5915 {
5916 arg2 = static_cast<int >(SWIG_As_int(obj1));
5917 if (SWIG_arg_fail(2)) SWIG_fail;
5918 }
5919 {
5920 arg3 = static_cast<int >(SWIG_As_int(obj2));
5921 if (SWIG_arg_fail(3)) SWIG_fail;
5922 }
5923 {
5924 PyThreadState* __tstate = wxPyBeginAllowThreads();
5925 {
5926 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5927 result = (wxRect *) &_result_ref;
5928 }
5929
5930 wxPyEndAllowThreads(__tstate);
5931 if (PyErr_Occurred()) SWIG_fail;
5932 }
5933 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5934 return resultobj;
5935 fail:
5936 return NULL;
5937 }
5938
5939
5940 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5941 PyObject *resultobj = NULL;
5942 wxRect *arg1 = (wxRect *) 0 ;
5943 int arg2 ;
5944 int arg3 ;
5945 PyObject * obj0 = 0 ;
5946 PyObject * obj1 = 0 ;
5947 PyObject * obj2 = 0 ;
5948 char *kwnames[] = {
5949 (char *) "self",(char *) "dx",(char *) "dy", NULL
5950 };
5951
5952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5954 if (SWIG_arg_fail(1)) SWIG_fail;
5955 {
5956 arg2 = static_cast<int >(SWIG_As_int(obj1));
5957 if (SWIG_arg_fail(2)) SWIG_fail;
5958 }
5959 {
5960 arg3 = static_cast<int >(SWIG_As_int(obj2));
5961 if (SWIG_arg_fail(3)) SWIG_fail;
5962 }
5963 {
5964 PyThreadState* __tstate = wxPyBeginAllowThreads();
5965 (arg1)->Offset(arg2,arg3);
5966
5967 wxPyEndAllowThreads(__tstate);
5968 if (PyErr_Occurred()) SWIG_fail;
5969 }
5970 Py_INCREF(Py_None); resultobj = Py_None;
5971 return resultobj;
5972 fail:
5973 return NULL;
5974 }
5975
5976
5977 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5978 PyObject *resultobj = NULL;
5979 wxRect *arg1 = (wxRect *) 0 ;
5980 wxPoint *arg2 = 0 ;
5981 wxPoint temp2 ;
5982 PyObject * obj0 = 0 ;
5983 PyObject * obj1 = 0 ;
5984 char *kwnames[] = {
5985 (char *) "self",(char *) "pt", NULL
5986 };
5987
5988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5990 if (SWIG_arg_fail(1)) SWIG_fail;
5991 {
5992 arg2 = &temp2;
5993 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5994 }
5995 {
5996 PyThreadState* __tstate = wxPyBeginAllowThreads();
5997 (arg1)->Offset((wxPoint const &)*arg2);
5998
5999 wxPyEndAllowThreads(__tstate);
6000 if (PyErr_Occurred()) SWIG_fail;
6001 }
6002 Py_INCREF(Py_None); resultobj = Py_None;
6003 return resultobj;
6004 fail:
6005 return NULL;
6006 }
6007
6008
6009 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
6010 PyObject *resultobj = NULL;
6011 wxRect *arg1 = (wxRect *) 0 ;
6012 wxRect *arg2 = 0 ;
6013 wxRect result;
6014 wxRect temp2 ;
6015 PyObject * obj0 = 0 ;
6016 PyObject * obj1 = 0 ;
6017 char *kwnames[] = {
6018 (char *) "self",(char *) "rect", NULL
6019 };
6020
6021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
6022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6023 if (SWIG_arg_fail(1)) SWIG_fail;
6024 {
6025 arg2 = &temp2;
6026 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6027 }
6028 {
6029 PyThreadState* __tstate = wxPyBeginAllowThreads();
6030 result = (arg1)->Intersect((wxRect const &)*arg2);
6031
6032 wxPyEndAllowThreads(__tstate);
6033 if (PyErr_Occurred()) SWIG_fail;
6034 }
6035 {
6036 wxRect * resultptr;
6037 resultptr = new wxRect(static_cast<wxRect & >(result));
6038 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6039 }
6040 return resultobj;
6041 fail:
6042 return NULL;
6043 }
6044
6045
6046 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6047 PyObject *resultobj = NULL;
6048 wxRect *arg1 = (wxRect *) 0 ;
6049 wxRect *arg2 = 0 ;
6050 wxRect result;
6051 wxRect temp2 ;
6052 PyObject * obj0 = 0 ;
6053 PyObject * obj1 = 0 ;
6054 char *kwnames[] = {
6055 (char *) "self",(char *) "rect", NULL
6056 };
6057
6058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
6059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6060 if (SWIG_arg_fail(1)) SWIG_fail;
6061 {
6062 arg2 = &temp2;
6063 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6064 }
6065 {
6066 PyThreadState* __tstate = wxPyBeginAllowThreads();
6067 result = (arg1)->Union((wxRect const &)*arg2);
6068
6069 wxPyEndAllowThreads(__tstate);
6070 if (PyErr_Occurred()) SWIG_fail;
6071 }
6072 {
6073 wxRect * resultptr;
6074 resultptr = new wxRect(static_cast<wxRect & >(result));
6075 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6076 }
6077 return resultobj;
6078 fail:
6079 return NULL;
6080 }
6081
6082
6083 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
6084 PyObject *resultobj = NULL;
6085 wxRect *arg1 = (wxRect *) 0 ;
6086 wxRect *arg2 = 0 ;
6087 wxRect result;
6088 wxRect temp2 ;
6089 PyObject * obj0 = 0 ;
6090 PyObject * obj1 = 0 ;
6091 char *kwnames[] = {
6092 (char *) "self",(char *) "rect", NULL
6093 };
6094
6095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
6096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6097 if (SWIG_arg_fail(1)) SWIG_fail;
6098 {
6099 arg2 = &temp2;
6100 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6101 }
6102 {
6103 PyThreadState* __tstate = wxPyBeginAllowThreads();
6104 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
6105
6106 wxPyEndAllowThreads(__tstate);
6107 if (PyErr_Occurred()) SWIG_fail;
6108 }
6109 {
6110 wxRect * resultptr;
6111 resultptr = new wxRect(static_cast<wxRect & >(result));
6112 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6113 }
6114 return resultobj;
6115 fail:
6116 return NULL;
6117 }
6118
6119
6120 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6121 PyObject *resultobj = NULL;
6122 wxRect *arg1 = (wxRect *) 0 ;
6123 wxRect *arg2 = 0 ;
6124 wxRect *result;
6125 wxRect temp2 ;
6126 PyObject * obj0 = 0 ;
6127 PyObject * obj1 = 0 ;
6128 char *kwnames[] = {
6129 (char *) "self",(char *) "rect", NULL
6130 };
6131
6132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
6133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6134 if (SWIG_arg_fail(1)) SWIG_fail;
6135 {
6136 arg2 = &temp2;
6137 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6138 }
6139 {
6140 PyThreadState* __tstate = wxPyBeginAllowThreads();
6141 {
6142 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
6143 result = (wxRect *) &_result_ref;
6144 }
6145
6146 wxPyEndAllowThreads(__tstate);
6147 if (PyErr_Occurred()) SWIG_fail;
6148 }
6149 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
6150 return resultobj;
6151 fail:
6152 return NULL;
6153 }
6154
6155
6156 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6157 PyObject *resultobj = NULL;
6158 wxRect *arg1 = (wxRect *) 0 ;
6159 wxRect *arg2 = 0 ;
6160 bool result;
6161 wxRect temp2 ;
6162 PyObject * obj0 = 0 ;
6163 PyObject * obj1 = 0 ;
6164 char *kwnames[] = {
6165 (char *) "self",(char *) "rect", NULL
6166 };
6167
6168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6170 if (SWIG_arg_fail(1)) SWIG_fail;
6171 {
6172 arg2 = &temp2;
6173 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6174 }
6175 {
6176 PyThreadState* __tstate = wxPyBeginAllowThreads();
6177 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6178
6179 wxPyEndAllowThreads(__tstate);
6180 if (PyErr_Occurred()) SWIG_fail;
6181 }
6182 {
6183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6184 }
6185 return resultobj;
6186 fail:
6187 return NULL;
6188 }
6189
6190
6191 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6192 PyObject *resultobj = NULL;
6193 wxRect *arg1 = (wxRect *) 0 ;
6194 wxRect *arg2 = 0 ;
6195 bool result;
6196 wxRect temp2 ;
6197 PyObject * obj0 = 0 ;
6198 PyObject * obj1 = 0 ;
6199 char *kwnames[] = {
6200 (char *) "self",(char *) "rect", NULL
6201 };
6202
6203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6205 if (SWIG_arg_fail(1)) SWIG_fail;
6206 {
6207 arg2 = &temp2;
6208 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6209 }
6210 {
6211 PyThreadState* __tstate = wxPyBeginAllowThreads();
6212 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6213
6214 wxPyEndAllowThreads(__tstate);
6215 if (PyErr_Occurred()) SWIG_fail;
6216 }
6217 {
6218 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6219 }
6220 return resultobj;
6221 fail:
6222 return NULL;
6223 }
6224
6225
6226 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6227 PyObject *resultobj = NULL;
6228 wxRect *arg1 = (wxRect *) 0 ;
6229 int arg2 ;
6230 int arg3 ;
6231 bool result;
6232 PyObject * obj0 = 0 ;
6233 PyObject * obj1 = 0 ;
6234 PyObject * obj2 = 0 ;
6235 char *kwnames[] = {
6236 (char *) "self",(char *) "x",(char *) "y", NULL
6237 };
6238
6239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6241 if (SWIG_arg_fail(1)) SWIG_fail;
6242 {
6243 arg2 = static_cast<int >(SWIG_As_int(obj1));
6244 if (SWIG_arg_fail(2)) SWIG_fail;
6245 }
6246 {
6247 arg3 = static_cast<int >(SWIG_As_int(obj2));
6248 if (SWIG_arg_fail(3)) SWIG_fail;
6249 }
6250 {
6251 PyThreadState* __tstate = wxPyBeginAllowThreads();
6252 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6253
6254 wxPyEndAllowThreads(__tstate);
6255 if (PyErr_Occurred()) SWIG_fail;
6256 }
6257 {
6258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6259 }
6260 return resultobj;
6261 fail:
6262 return NULL;
6263 }
6264
6265
6266 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6267 PyObject *resultobj = NULL;
6268 wxRect *arg1 = (wxRect *) 0 ;
6269 wxPoint *arg2 = 0 ;
6270 bool result;
6271 wxPoint temp2 ;
6272 PyObject * obj0 = 0 ;
6273 PyObject * obj1 = 0 ;
6274 char *kwnames[] = {
6275 (char *) "self",(char *) "pt", NULL
6276 };
6277
6278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6280 if (SWIG_arg_fail(1)) SWIG_fail;
6281 {
6282 arg2 = &temp2;
6283 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6284 }
6285 {
6286 PyThreadState* __tstate = wxPyBeginAllowThreads();
6287 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6288
6289 wxPyEndAllowThreads(__tstate);
6290 if (PyErr_Occurred()) SWIG_fail;
6291 }
6292 {
6293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6294 }
6295 return resultobj;
6296 fail:
6297 return NULL;
6298 }
6299
6300
6301 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6302 PyObject *resultobj = NULL;
6303 wxRect *arg1 = (wxRect *) 0 ;
6304 wxRect *arg2 = 0 ;
6305 bool result;
6306 wxRect temp2 ;
6307 PyObject * obj0 = 0 ;
6308 PyObject * obj1 = 0 ;
6309 char *kwnames[] = {
6310 (char *) "self",(char *) "rect", NULL
6311 };
6312
6313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6315 if (SWIG_arg_fail(1)) SWIG_fail;
6316 {
6317 arg2 = &temp2;
6318 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6319 }
6320 {
6321 PyThreadState* __tstate = wxPyBeginAllowThreads();
6322 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6323
6324 wxPyEndAllowThreads(__tstate);
6325 if (PyErr_Occurred()) SWIG_fail;
6326 }
6327 {
6328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6329 }
6330 return resultobj;
6331 fail:
6332 return NULL;
6333 }
6334
6335
6336 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6337 PyObject *resultobj = NULL;
6338 wxRect *arg1 = (wxRect *) 0 ;
6339 int arg2 ;
6340 PyObject * obj0 = 0 ;
6341 PyObject * obj1 = 0 ;
6342 char *kwnames[] = {
6343 (char *) "self",(char *) "x", NULL
6344 };
6345
6346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6348 if (SWIG_arg_fail(1)) SWIG_fail;
6349 {
6350 arg2 = static_cast<int >(SWIG_As_int(obj1));
6351 if (SWIG_arg_fail(2)) SWIG_fail;
6352 }
6353 if (arg1) (arg1)->x = arg2;
6354
6355 Py_INCREF(Py_None); resultobj = Py_None;
6356 return resultobj;
6357 fail:
6358 return NULL;
6359 }
6360
6361
6362 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6363 PyObject *resultobj = NULL;
6364 wxRect *arg1 = (wxRect *) 0 ;
6365 int result;
6366 PyObject * obj0 = 0 ;
6367 char *kwnames[] = {
6368 (char *) "self", NULL
6369 };
6370
6371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6373 if (SWIG_arg_fail(1)) SWIG_fail;
6374 result = (int) ((arg1)->x);
6375
6376 {
6377 resultobj = SWIG_From_int(static_cast<int >(result));
6378 }
6379 return resultobj;
6380 fail:
6381 return NULL;
6382 }
6383
6384
6385 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6386 PyObject *resultobj = NULL;
6387 wxRect *arg1 = (wxRect *) 0 ;
6388 int arg2 ;
6389 PyObject * obj0 = 0 ;
6390 PyObject * obj1 = 0 ;
6391 char *kwnames[] = {
6392 (char *) "self",(char *) "y", NULL
6393 };
6394
6395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6397 if (SWIG_arg_fail(1)) SWIG_fail;
6398 {
6399 arg2 = static_cast<int >(SWIG_As_int(obj1));
6400 if (SWIG_arg_fail(2)) SWIG_fail;
6401 }
6402 if (arg1) (arg1)->y = arg2;
6403
6404 Py_INCREF(Py_None); resultobj = Py_None;
6405 return resultobj;
6406 fail:
6407 return NULL;
6408 }
6409
6410
6411 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6412 PyObject *resultobj = NULL;
6413 wxRect *arg1 = (wxRect *) 0 ;
6414 int result;
6415 PyObject * obj0 = 0 ;
6416 char *kwnames[] = {
6417 (char *) "self", NULL
6418 };
6419
6420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6422 if (SWIG_arg_fail(1)) SWIG_fail;
6423 result = (int) ((arg1)->y);
6424
6425 {
6426 resultobj = SWIG_From_int(static_cast<int >(result));
6427 }
6428 return resultobj;
6429 fail:
6430 return NULL;
6431 }
6432
6433
6434 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6435 PyObject *resultobj = NULL;
6436 wxRect *arg1 = (wxRect *) 0 ;
6437 int arg2 ;
6438 PyObject * obj0 = 0 ;
6439 PyObject * obj1 = 0 ;
6440 char *kwnames[] = {
6441 (char *) "self",(char *) "width", NULL
6442 };
6443
6444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6446 if (SWIG_arg_fail(1)) SWIG_fail;
6447 {
6448 arg2 = static_cast<int >(SWIG_As_int(obj1));
6449 if (SWIG_arg_fail(2)) SWIG_fail;
6450 }
6451 if (arg1) (arg1)->width = arg2;
6452
6453 Py_INCREF(Py_None); resultobj = Py_None;
6454 return resultobj;
6455 fail:
6456 return NULL;
6457 }
6458
6459
6460 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6461 PyObject *resultobj = NULL;
6462 wxRect *arg1 = (wxRect *) 0 ;
6463 int result;
6464 PyObject * obj0 = 0 ;
6465 char *kwnames[] = {
6466 (char *) "self", NULL
6467 };
6468
6469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6471 if (SWIG_arg_fail(1)) SWIG_fail;
6472 result = (int) ((arg1)->width);
6473
6474 {
6475 resultobj = SWIG_From_int(static_cast<int >(result));
6476 }
6477 return resultobj;
6478 fail:
6479 return NULL;
6480 }
6481
6482
6483 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6484 PyObject *resultobj = NULL;
6485 wxRect *arg1 = (wxRect *) 0 ;
6486 int arg2 ;
6487 PyObject * obj0 = 0 ;
6488 PyObject * obj1 = 0 ;
6489 char *kwnames[] = {
6490 (char *) "self",(char *) "height", NULL
6491 };
6492
6493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6495 if (SWIG_arg_fail(1)) SWIG_fail;
6496 {
6497 arg2 = static_cast<int >(SWIG_As_int(obj1));
6498 if (SWIG_arg_fail(2)) SWIG_fail;
6499 }
6500 if (arg1) (arg1)->height = arg2;
6501
6502 Py_INCREF(Py_None); resultobj = Py_None;
6503 return resultobj;
6504 fail:
6505 return NULL;
6506 }
6507
6508
6509 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6510 PyObject *resultobj = NULL;
6511 wxRect *arg1 = (wxRect *) 0 ;
6512 int result;
6513 PyObject * obj0 = 0 ;
6514 char *kwnames[] = {
6515 (char *) "self", NULL
6516 };
6517
6518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6520 if (SWIG_arg_fail(1)) SWIG_fail;
6521 result = (int) ((arg1)->height);
6522
6523 {
6524 resultobj = SWIG_From_int(static_cast<int >(result));
6525 }
6526 return resultobj;
6527 fail:
6528 return NULL;
6529 }
6530
6531
6532 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6533 PyObject *resultobj = NULL;
6534 wxRect *arg1 = (wxRect *) 0 ;
6535 int arg2 = (int) 0 ;
6536 int arg3 = (int) 0 ;
6537 int arg4 = (int) 0 ;
6538 int arg5 = (int) 0 ;
6539 PyObject * obj0 = 0 ;
6540 PyObject * obj1 = 0 ;
6541 PyObject * obj2 = 0 ;
6542 PyObject * obj3 = 0 ;
6543 PyObject * obj4 = 0 ;
6544 char *kwnames[] = {
6545 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6546 };
6547
6548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6550 if (SWIG_arg_fail(1)) SWIG_fail;
6551 if (obj1) {
6552 {
6553 arg2 = static_cast<int >(SWIG_As_int(obj1));
6554 if (SWIG_arg_fail(2)) SWIG_fail;
6555 }
6556 }
6557 if (obj2) {
6558 {
6559 arg3 = static_cast<int >(SWIG_As_int(obj2));
6560 if (SWIG_arg_fail(3)) SWIG_fail;
6561 }
6562 }
6563 if (obj3) {
6564 {
6565 arg4 = static_cast<int >(SWIG_As_int(obj3));
6566 if (SWIG_arg_fail(4)) SWIG_fail;
6567 }
6568 }
6569 if (obj4) {
6570 {
6571 arg5 = static_cast<int >(SWIG_As_int(obj4));
6572 if (SWIG_arg_fail(5)) SWIG_fail;
6573 }
6574 }
6575 {
6576 PyThreadState* __tstate = wxPyBeginAllowThreads();
6577 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6578
6579 wxPyEndAllowThreads(__tstate);
6580 if (PyErr_Occurred()) SWIG_fail;
6581 }
6582 Py_INCREF(Py_None); resultobj = Py_None;
6583 return resultobj;
6584 fail:
6585 return NULL;
6586 }
6587
6588
6589 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6590 PyObject *resultobj = NULL;
6591 wxRect *arg1 = (wxRect *) 0 ;
6592 PyObject *result;
6593 PyObject * obj0 = 0 ;
6594 char *kwnames[] = {
6595 (char *) "self", NULL
6596 };
6597
6598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6600 if (SWIG_arg_fail(1)) SWIG_fail;
6601 {
6602 PyThreadState* __tstate = wxPyBeginAllowThreads();
6603 result = (PyObject *)wxRect_Get(arg1);
6604
6605 wxPyEndAllowThreads(__tstate);
6606 if (PyErr_Occurred()) SWIG_fail;
6607 }
6608 resultobj = result;
6609 return resultobj;
6610 fail:
6611 return NULL;
6612 }
6613
6614
6615 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6616 PyObject *obj;
6617 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6618 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6619 Py_INCREF(obj);
6620 return Py_BuildValue((char *)"");
6621 }
6622 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6623 PyObject *resultobj = NULL;
6624 wxRect *arg1 = (wxRect *) 0 ;
6625 wxRect *arg2 = (wxRect *) 0 ;
6626 PyObject *result;
6627 PyObject * obj0 = 0 ;
6628 PyObject * obj1 = 0 ;
6629 char *kwnames[] = {
6630 (char *) "r1",(char *) "r2", NULL
6631 };
6632
6633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6635 if (SWIG_arg_fail(1)) SWIG_fail;
6636 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6637 if (SWIG_arg_fail(2)) SWIG_fail;
6638 {
6639 if (!wxPyCheckForApp()) SWIG_fail;
6640 PyThreadState* __tstate = wxPyBeginAllowThreads();
6641 result = (PyObject *)wxIntersectRect(arg1,arg2);
6642
6643 wxPyEndAllowThreads(__tstate);
6644 if (PyErr_Occurred()) SWIG_fail;
6645 }
6646 resultobj = result;
6647 return resultobj;
6648 fail:
6649 return NULL;
6650 }
6651
6652
6653 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6654 PyObject *resultobj = NULL;
6655 double arg1 = (double) 0.0 ;
6656 double arg2 = (double) 0.0 ;
6657 wxPoint2D *result;
6658 PyObject * obj0 = 0 ;
6659 PyObject * obj1 = 0 ;
6660 char *kwnames[] = {
6661 (char *) "x",(char *) "y", NULL
6662 };
6663
6664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6665 if (obj0) {
6666 {
6667 arg1 = static_cast<double >(SWIG_As_double(obj0));
6668 if (SWIG_arg_fail(1)) SWIG_fail;
6669 }
6670 }
6671 if (obj1) {
6672 {
6673 arg2 = static_cast<double >(SWIG_As_double(obj1));
6674 if (SWIG_arg_fail(2)) SWIG_fail;
6675 }
6676 }
6677 {
6678 PyThreadState* __tstate = wxPyBeginAllowThreads();
6679 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6680
6681 wxPyEndAllowThreads(__tstate);
6682 if (PyErr_Occurred()) SWIG_fail;
6683 }
6684 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6685 return resultobj;
6686 fail:
6687 return NULL;
6688 }
6689
6690
6691 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6692 PyObject *resultobj = NULL;
6693 wxPoint2D *arg1 = 0 ;
6694 wxPoint2D *result;
6695 wxPoint2D temp1 ;
6696 PyObject * obj0 = 0 ;
6697 char *kwnames[] = {
6698 (char *) "pt", NULL
6699 };
6700
6701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6702 {
6703 arg1 = &temp1;
6704 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6705 }
6706 {
6707 PyThreadState* __tstate = wxPyBeginAllowThreads();
6708 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6709
6710 wxPyEndAllowThreads(__tstate);
6711 if (PyErr_Occurred()) SWIG_fail;
6712 }
6713 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6714 return resultobj;
6715 fail:
6716 return NULL;
6717 }
6718
6719
6720 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6721 PyObject *resultobj = NULL;
6722 wxPoint *arg1 = 0 ;
6723 wxPoint2D *result;
6724 wxPoint temp1 ;
6725 PyObject * obj0 = 0 ;
6726 char *kwnames[] = {
6727 (char *) "pt", NULL
6728 };
6729
6730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6731 {
6732 arg1 = &temp1;
6733 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6734 }
6735 {
6736 PyThreadState* __tstate = wxPyBeginAllowThreads();
6737 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6738
6739 wxPyEndAllowThreads(__tstate);
6740 if (PyErr_Occurred()) SWIG_fail;
6741 }
6742 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6743 return resultobj;
6744 fail:
6745 return NULL;
6746 }
6747
6748
6749 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6750 PyObject *resultobj = NULL;
6751 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6752 int *arg2 = (int *) 0 ;
6753 int *arg3 = (int *) 0 ;
6754 int temp2 ;
6755 int res2 = 0 ;
6756 int temp3 ;
6757 int res3 = 0 ;
6758 PyObject * obj0 = 0 ;
6759 char *kwnames[] = {
6760 (char *) "self", NULL
6761 };
6762
6763 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6764 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6767 if (SWIG_arg_fail(1)) SWIG_fail;
6768 {
6769 PyThreadState* __tstate = wxPyBeginAllowThreads();
6770 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6771
6772 wxPyEndAllowThreads(__tstate);
6773 if (PyErr_Occurred()) SWIG_fail;
6774 }
6775 Py_INCREF(Py_None); resultobj = Py_None;
6776 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6777 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6778 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6779 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6780 return resultobj;
6781 fail:
6782 return NULL;
6783 }
6784
6785
6786 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6787 PyObject *resultobj = NULL;
6788 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6789 int *arg2 = (int *) 0 ;
6790 int *arg3 = (int *) 0 ;
6791 int temp2 ;
6792 int res2 = 0 ;
6793 int temp3 ;
6794 int res3 = 0 ;
6795 PyObject * obj0 = 0 ;
6796 char *kwnames[] = {
6797 (char *) "self", NULL
6798 };
6799
6800 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6801 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6804 if (SWIG_arg_fail(1)) SWIG_fail;
6805 {
6806 PyThreadState* __tstate = wxPyBeginAllowThreads();
6807 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6808
6809 wxPyEndAllowThreads(__tstate);
6810 if (PyErr_Occurred()) SWIG_fail;
6811 }
6812 Py_INCREF(Py_None); resultobj = Py_None;
6813 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6814 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6815 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6816 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6817 return resultobj;
6818 fail:
6819 return NULL;
6820 }
6821
6822
6823 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6824 PyObject *resultobj = NULL;
6825 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6826 double result;
6827 PyObject * obj0 = 0 ;
6828 char *kwnames[] = {
6829 (char *) "self", NULL
6830 };
6831
6832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6834 if (SWIG_arg_fail(1)) SWIG_fail;
6835 {
6836 PyThreadState* __tstate = wxPyBeginAllowThreads();
6837 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6838
6839 wxPyEndAllowThreads(__tstate);
6840 if (PyErr_Occurred()) SWIG_fail;
6841 }
6842 {
6843 resultobj = SWIG_From_double(static_cast<double >(result));
6844 }
6845 return resultobj;
6846 fail:
6847 return NULL;
6848 }
6849
6850
6851 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6852 PyObject *resultobj = NULL;
6853 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6854 double result;
6855 PyObject * obj0 = 0 ;
6856 char *kwnames[] = {
6857 (char *) "self", NULL
6858 };
6859
6860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6862 if (SWIG_arg_fail(1)) SWIG_fail;
6863 {
6864 PyThreadState* __tstate = wxPyBeginAllowThreads();
6865 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6866
6867 wxPyEndAllowThreads(__tstate);
6868 if (PyErr_Occurred()) SWIG_fail;
6869 }
6870 {
6871 resultobj = SWIG_From_double(static_cast<double >(result));
6872 }
6873 return resultobj;
6874 fail:
6875 return NULL;
6876 }
6877
6878
6879 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6880 PyObject *resultobj = NULL;
6881 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6882 double arg2 ;
6883 PyObject * obj0 = 0 ;
6884 PyObject * obj1 = 0 ;
6885 char *kwnames[] = {
6886 (char *) "self",(char *) "length", NULL
6887 };
6888
6889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6891 if (SWIG_arg_fail(1)) SWIG_fail;
6892 {
6893 arg2 = static_cast<double >(SWIG_As_double(obj1));
6894 if (SWIG_arg_fail(2)) SWIG_fail;
6895 }
6896 {
6897 PyThreadState* __tstate = wxPyBeginAllowThreads();
6898 (arg1)->SetVectorLength(arg2);
6899
6900 wxPyEndAllowThreads(__tstate);
6901 if (PyErr_Occurred()) SWIG_fail;
6902 }
6903 Py_INCREF(Py_None); resultobj = Py_None;
6904 return resultobj;
6905 fail:
6906 return NULL;
6907 }
6908
6909
6910 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6911 PyObject *resultobj = NULL;
6912 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6913 double arg2 ;
6914 PyObject * obj0 = 0 ;
6915 PyObject * obj1 = 0 ;
6916 char *kwnames[] = {
6917 (char *) "self",(char *) "degrees", NULL
6918 };
6919
6920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6922 if (SWIG_arg_fail(1)) SWIG_fail;
6923 {
6924 arg2 = static_cast<double >(SWIG_As_double(obj1));
6925 if (SWIG_arg_fail(2)) SWIG_fail;
6926 }
6927 {
6928 PyThreadState* __tstate = wxPyBeginAllowThreads();
6929 (arg1)->SetVectorAngle(arg2);
6930
6931 wxPyEndAllowThreads(__tstate);
6932 if (PyErr_Occurred()) SWIG_fail;
6933 }
6934 Py_INCREF(Py_None); resultobj = Py_None;
6935 return resultobj;
6936 fail:
6937 return NULL;
6938 }
6939
6940
6941 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6942 PyObject *resultobj = NULL;
6943 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6944 wxPoint2D *arg2 = 0 ;
6945 double result;
6946 wxPoint2D temp2 ;
6947 PyObject * obj0 = 0 ;
6948 PyObject * obj1 = 0 ;
6949 char *kwnames[] = {
6950 (char *) "self",(char *) "pt", NULL
6951 };
6952
6953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6955 if (SWIG_arg_fail(1)) SWIG_fail;
6956 {
6957 arg2 = &temp2;
6958 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6959 }
6960 {
6961 PyThreadState* __tstate = wxPyBeginAllowThreads();
6962 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6963
6964 wxPyEndAllowThreads(__tstate);
6965 if (PyErr_Occurred()) SWIG_fail;
6966 }
6967 {
6968 resultobj = SWIG_From_double(static_cast<double >(result));
6969 }
6970 return resultobj;
6971 fail:
6972 return NULL;
6973 }
6974
6975
6976 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6977 PyObject *resultobj = NULL;
6978 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6979 wxPoint2D *arg2 = 0 ;
6980 double result;
6981 wxPoint2D temp2 ;
6982 PyObject * obj0 = 0 ;
6983 PyObject * obj1 = 0 ;
6984 char *kwnames[] = {
6985 (char *) "self",(char *) "pt", NULL
6986 };
6987
6988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6990 if (SWIG_arg_fail(1)) SWIG_fail;
6991 {
6992 arg2 = &temp2;
6993 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6994 }
6995 {
6996 PyThreadState* __tstate = wxPyBeginAllowThreads();
6997 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6998
6999 wxPyEndAllowThreads(__tstate);
7000 if (PyErr_Occurred()) SWIG_fail;
7001 }
7002 {
7003 resultobj = SWIG_From_double(static_cast<double >(result));
7004 }
7005 return resultobj;
7006 fail:
7007 return NULL;
7008 }
7009
7010
7011 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
7012 PyObject *resultobj = NULL;
7013 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7014 wxPoint2D *arg2 = 0 ;
7015 double result;
7016 wxPoint2D temp2 ;
7017 PyObject * obj0 = 0 ;
7018 PyObject * obj1 = 0 ;
7019 char *kwnames[] = {
7020 (char *) "self",(char *) "vec", NULL
7021 };
7022
7023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
7024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7025 if (SWIG_arg_fail(1)) SWIG_fail;
7026 {
7027 arg2 = &temp2;
7028 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7029 }
7030 {
7031 PyThreadState* __tstate = wxPyBeginAllowThreads();
7032 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
7033
7034 wxPyEndAllowThreads(__tstate);
7035 if (PyErr_Occurred()) SWIG_fail;
7036 }
7037 {
7038 resultobj = SWIG_From_double(static_cast<double >(result));
7039 }
7040 return resultobj;
7041 fail:
7042 return NULL;
7043 }
7044
7045
7046 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
7047 PyObject *resultobj = NULL;
7048 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7049 wxPoint2D *arg2 = 0 ;
7050 double result;
7051 wxPoint2D temp2 ;
7052 PyObject * obj0 = 0 ;
7053 PyObject * obj1 = 0 ;
7054 char *kwnames[] = {
7055 (char *) "self",(char *) "vec", NULL
7056 };
7057
7058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
7059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7060 if (SWIG_arg_fail(1)) SWIG_fail;
7061 {
7062 arg2 = &temp2;
7063 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7064 }
7065 {
7066 PyThreadState* __tstate = wxPyBeginAllowThreads();
7067 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
7068
7069 wxPyEndAllowThreads(__tstate);
7070 if (PyErr_Occurred()) SWIG_fail;
7071 }
7072 {
7073 resultobj = SWIG_From_double(static_cast<double >(result));
7074 }
7075 return resultobj;
7076 fail:
7077 return NULL;
7078 }
7079
7080
7081 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
7082 PyObject *resultobj = NULL;
7083 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7084 wxPoint2D result;
7085 PyObject * obj0 = 0 ;
7086 char *kwnames[] = {
7087 (char *) "self", NULL
7088 };
7089
7090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
7091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7092 if (SWIG_arg_fail(1)) SWIG_fail;
7093 {
7094 PyThreadState* __tstate = wxPyBeginAllowThreads();
7095 result = (arg1)->operator -();
7096
7097 wxPyEndAllowThreads(__tstate);
7098 if (PyErr_Occurred()) SWIG_fail;
7099 }
7100 {
7101 wxPoint2D * resultptr;
7102 resultptr = new wxPoint2D(static_cast<wxPoint2D & >(result));
7103 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
7104 }
7105 return resultobj;
7106 fail:
7107 return NULL;
7108 }
7109
7110
7111 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
7112 PyObject *resultobj = NULL;
7113 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7114 wxPoint2D *arg2 = 0 ;
7115 wxPoint2D *result;
7116 wxPoint2D temp2 ;
7117 PyObject * obj0 = 0 ;
7118 PyObject * obj1 = 0 ;
7119 char *kwnames[] = {
7120 (char *) "self",(char *) "pt", NULL
7121 };
7122
7123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
7124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7125 if (SWIG_arg_fail(1)) SWIG_fail;
7126 {
7127 arg2 = &temp2;
7128 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7129 }
7130 {
7131 PyThreadState* __tstate = wxPyBeginAllowThreads();
7132 {
7133 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
7134 result = (wxPoint2D *) &_result_ref;
7135 }
7136
7137 wxPyEndAllowThreads(__tstate);
7138 if (PyErr_Occurred()) SWIG_fail;
7139 }
7140 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7141 return resultobj;
7142 fail:
7143 return NULL;
7144 }
7145
7146
7147 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
7148 PyObject *resultobj = NULL;
7149 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7150 wxPoint2D *arg2 = 0 ;
7151 wxPoint2D *result;
7152 wxPoint2D temp2 ;
7153 PyObject * obj0 = 0 ;
7154 PyObject * obj1 = 0 ;
7155 char *kwnames[] = {
7156 (char *) "self",(char *) "pt", NULL
7157 };
7158
7159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7161 if (SWIG_arg_fail(1)) SWIG_fail;
7162 {
7163 arg2 = &temp2;
7164 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7165 }
7166 {
7167 PyThreadState* __tstate = wxPyBeginAllowThreads();
7168 {
7169 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7170 result = (wxPoint2D *) &_result_ref;
7171 }
7172
7173 wxPyEndAllowThreads(__tstate);
7174 if (PyErr_Occurred()) SWIG_fail;
7175 }
7176 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7177 return resultobj;
7178 fail:
7179 return NULL;
7180 }
7181
7182
7183 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7184 PyObject *resultobj = NULL;
7185 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7186 wxPoint2D *arg2 = 0 ;
7187 wxPoint2D *result;
7188 wxPoint2D temp2 ;
7189 PyObject * obj0 = 0 ;
7190 PyObject * obj1 = 0 ;
7191 char *kwnames[] = {
7192 (char *) "self",(char *) "pt", NULL
7193 };
7194
7195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7197 if (SWIG_arg_fail(1)) SWIG_fail;
7198 {
7199 arg2 = &temp2;
7200 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7201 }
7202 {
7203 PyThreadState* __tstate = wxPyBeginAllowThreads();
7204 {
7205 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7206 result = (wxPoint2D *) &_result_ref;
7207 }
7208
7209 wxPyEndAllowThreads(__tstate);
7210 if (PyErr_Occurred()) SWIG_fail;
7211 }
7212 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7213 return resultobj;
7214 fail:
7215 return NULL;
7216 }
7217
7218
7219 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7220 PyObject *resultobj = NULL;
7221 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7222 wxPoint2D *arg2 = 0 ;
7223 wxPoint2D *result;
7224 wxPoint2D temp2 ;
7225 PyObject * obj0 = 0 ;
7226 PyObject * obj1 = 0 ;
7227 char *kwnames[] = {
7228 (char *) "self",(char *) "pt", NULL
7229 };
7230
7231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7233 if (SWIG_arg_fail(1)) SWIG_fail;
7234 {
7235 arg2 = &temp2;
7236 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7237 }
7238 {
7239 PyThreadState* __tstate = wxPyBeginAllowThreads();
7240 {
7241 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7242 result = (wxPoint2D *) &_result_ref;
7243 }
7244
7245 wxPyEndAllowThreads(__tstate);
7246 if (PyErr_Occurred()) SWIG_fail;
7247 }
7248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7249 return resultobj;
7250 fail:
7251 return NULL;
7252 }
7253
7254
7255 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7256 PyObject *resultobj = NULL;
7257 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7258 wxPoint2D *arg2 = 0 ;
7259 bool result;
7260 wxPoint2D temp2 ;
7261 PyObject * obj0 = 0 ;
7262 PyObject * obj1 = 0 ;
7263 char *kwnames[] = {
7264 (char *) "self",(char *) "pt", NULL
7265 };
7266
7267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7269 if (SWIG_arg_fail(1)) SWIG_fail;
7270 {
7271 arg2 = &temp2;
7272 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7273 }
7274 {
7275 PyThreadState* __tstate = wxPyBeginAllowThreads();
7276 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7277
7278 wxPyEndAllowThreads(__tstate);
7279 if (PyErr_Occurred()) SWIG_fail;
7280 }
7281 {
7282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7283 }
7284 return resultobj;
7285 fail:
7286 return NULL;
7287 }
7288
7289
7290 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7291 PyObject *resultobj = NULL;
7292 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7293 wxPoint2D *arg2 = 0 ;
7294 bool result;
7295 wxPoint2D temp2 ;
7296 PyObject * obj0 = 0 ;
7297 PyObject * obj1 = 0 ;
7298 char *kwnames[] = {
7299 (char *) "self",(char *) "pt", NULL
7300 };
7301
7302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7304 if (SWIG_arg_fail(1)) SWIG_fail;
7305 {
7306 arg2 = &temp2;
7307 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7308 }
7309 {
7310 PyThreadState* __tstate = wxPyBeginAllowThreads();
7311 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7312
7313 wxPyEndAllowThreads(__tstate);
7314 if (PyErr_Occurred()) SWIG_fail;
7315 }
7316 {
7317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7318 }
7319 return resultobj;
7320 fail:
7321 return NULL;
7322 }
7323
7324
7325 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7326 PyObject *resultobj = NULL;
7327 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7328 double arg2 ;
7329 PyObject * obj0 = 0 ;
7330 PyObject * obj1 = 0 ;
7331 char *kwnames[] = {
7332 (char *) "self",(char *) "m_x", NULL
7333 };
7334
7335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7337 if (SWIG_arg_fail(1)) SWIG_fail;
7338 {
7339 arg2 = static_cast<double >(SWIG_As_double(obj1));
7340 if (SWIG_arg_fail(2)) SWIG_fail;
7341 }
7342 if (arg1) (arg1)->m_x = arg2;
7343
7344 Py_INCREF(Py_None); resultobj = Py_None;
7345 return resultobj;
7346 fail:
7347 return NULL;
7348 }
7349
7350
7351 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7352 PyObject *resultobj = NULL;
7353 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7354 double result;
7355 PyObject * obj0 = 0 ;
7356 char *kwnames[] = {
7357 (char *) "self", NULL
7358 };
7359
7360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7362 if (SWIG_arg_fail(1)) SWIG_fail;
7363 result = (double) ((arg1)->m_x);
7364
7365 {
7366 resultobj = SWIG_From_double(static_cast<double >(result));
7367 }
7368 return resultobj;
7369 fail:
7370 return NULL;
7371 }
7372
7373
7374 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7375 PyObject *resultobj = NULL;
7376 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7377 double arg2 ;
7378 PyObject * obj0 = 0 ;
7379 PyObject * obj1 = 0 ;
7380 char *kwnames[] = {
7381 (char *) "self",(char *) "m_y", NULL
7382 };
7383
7384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7386 if (SWIG_arg_fail(1)) SWIG_fail;
7387 {
7388 arg2 = static_cast<double >(SWIG_As_double(obj1));
7389 if (SWIG_arg_fail(2)) SWIG_fail;
7390 }
7391 if (arg1) (arg1)->m_y = arg2;
7392
7393 Py_INCREF(Py_None); resultobj = Py_None;
7394 return resultobj;
7395 fail:
7396 return NULL;
7397 }
7398
7399
7400 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7401 PyObject *resultobj = NULL;
7402 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7403 double result;
7404 PyObject * obj0 = 0 ;
7405 char *kwnames[] = {
7406 (char *) "self", NULL
7407 };
7408
7409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7411 if (SWIG_arg_fail(1)) SWIG_fail;
7412 result = (double) ((arg1)->m_y);
7413
7414 {
7415 resultobj = SWIG_From_double(static_cast<double >(result));
7416 }
7417 return resultobj;
7418 fail:
7419 return NULL;
7420 }
7421
7422
7423 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7424 PyObject *resultobj = NULL;
7425 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7426 double arg2 = (double) 0 ;
7427 double arg3 = (double) 0 ;
7428 PyObject * obj0 = 0 ;
7429 PyObject * obj1 = 0 ;
7430 PyObject * obj2 = 0 ;
7431 char *kwnames[] = {
7432 (char *) "self",(char *) "x",(char *) "y", NULL
7433 };
7434
7435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7437 if (SWIG_arg_fail(1)) SWIG_fail;
7438 if (obj1) {
7439 {
7440 arg2 = static_cast<double >(SWIG_As_double(obj1));
7441 if (SWIG_arg_fail(2)) SWIG_fail;
7442 }
7443 }
7444 if (obj2) {
7445 {
7446 arg3 = static_cast<double >(SWIG_As_double(obj2));
7447 if (SWIG_arg_fail(3)) SWIG_fail;
7448 }
7449 }
7450 {
7451 PyThreadState* __tstate = wxPyBeginAllowThreads();
7452 wxPoint2D_Set(arg1,arg2,arg3);
7453
7454 wxPyEndAllowThreads(__tstate);
7455 if (PyErr_Occurred()) SWIG_fail;
7456 }
7457 Py_INCREF(Py_None); resultobj = Py_None;
7458 return resultobj;
7459 fail:
7460 return NULL;
7461 }
7462
7463
7464 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7465 PyObject *resultobj = NULL;
7466 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7467 PyObject *result;
7468 PyObject * obj0 = 0 ;
7469 char *kwnames[] = {
7470 (char *) "self", NULL
7471 };
7472
7473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7475 if (SWIG_arg_fail(1)) SWIG_fail;
7476 {
7477 PyThreadState* __tstate = wxPyBeginAllowThreads();
7478 result = (PyObject *)wxPoint2D_Get(arg1);
7479
7480 wxPyEndAllowThreads(__tstate);
7481 if (PyErr_Occurred()) SWIG_fail;
7482 }
7483 resultobj = result;
7484 return resultobj;
7485 fail:
7486 return NULL;
7487 }
7488
7489
7490 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7491 PyObject *obj;
7492 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7493 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7494 Py_INCREF(obj);
7495 return Py_BuildValue((char *)"");
7496 }
7497 static int _wrap_DefaultPosition_set(PyObject *) {
7498 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7499 return 1;
7500 }
7501
7502
7503 static PyObject *_wrap_DefaultPosition_get(void) {
7504 PyObject *pyobj = NULL;
7505
7506 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7507 return pyobj;
7508 }
7509
7510
7511 static int _wrap_DefaultSize_set(PyObject *) {
7512 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7513 return 1;
7514 }
7515
7516
7517 static PyObject *_wrap_DefaultSize_get(void) {
7518 PyObject *pyobj = NULL;
7519
7520 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7521 return pyobj;
7522 }
7523
7524
7525 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7526 PyObject *resultobj = NULL;
7527 PyObject *arg1 = (PyObject *) 0 ;
7528 wxPyInputStream *result;
7529 PyObject * obj0 = 0 ;
7530 char *kwnames[] = {
7531 (char *) "p", NULL
7532 };
7533
7534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7535 arg1 = obj0;
7536 {
7537 PyThreadState* __tstate = wxPyBeginAllowThreads();
7538 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7539
7540 wxPyEndAllowThreads(__tstate);
7541 if (PyErr_Occurred()) SWIG_fail;
7542 }
7543 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7544 return resultobj;
7545 fail:
7546 return NULL;
7547 }
7548
7549
7550 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7551 PyObject *resultobj = NULL;
7552 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7553 PyObject * obj0 = 0 ;
7554 char *kwnames[] = {
7555 (char *) "self", NULL
7556 };
7557
7558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7560 if (SWIG_arg_fail(1)) SWIG_fail;
7561 {
7562 PyThreadState* __tstate = wxPyBeginAllowThreads();
7563 delete arg1;
7564
7565 wxPyEndAllowThreads(__tstate);
7566 if (PyErr_Occurred()) SWIG_fail;
7567 }
7568 Py_INCREF(Py_None); resultobj = Py_None;
7569 return resultobj;
7570 fail:
7571 return NULL;
7572 }
7573
7574
7575 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7576 PyObject *resultobj = NULL;
7577 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7578 PyObject * obj0 = 0 ;
7579 char *kwnames[] = {
7580 (char *) "self", NULL
7581 };
7582
7583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7585 if (SWIG_arg_fail(1)) SWIG_fail;
7586 {
7587 PyThreadState* __tstate = wxPyBeginAllowThreads();
7588 (arg1)->close();
7589
7590 wxPyEndAllowThreads(__tstate);
7591 if (PyErr_Occurred()) SWIG_fail;
7592 }
7593 Py_INCREF(Py_None); resultobj = Py_None;
7594 return resultobj;
7595 fail:
7596 return NULL;
7597 }
7598
7599
7600 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7601 PyObject *resultobj = NULL;
7602 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7603 PyObject * obj0 = 0 ;
7604 char *kwnames[] = {
7605 (char *) "self", NULL
7606 };
7607
7608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7610 if (SWIG_arg_fail(1)) SWIG_fail;
7611 {
7612 PyThreadState* __tstate = wxPyBeginAllowThreads();
7613 (arg1)->flush();
7614
7615 wxPyEndAllowThreads(__tstate);
7616 if (PyErr_Occurred()) SWIG_fail;
7617 }
7618 Py_INCREF(Py_None); resultobj = Py_None;
7619 return resultobj;
7620 fail:
7621 return NULL;
7622 }
7623
7624
7625 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7626 PyObject *resultobj = NULL;
7627 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7628 bool result;
7629 PyObject * obj0 = 0 ;
7630 char *kwnames[] = {
7631 (char *) "self", NULL
7632 };
7633
7634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7636 if (SWIG_arg_fail(1)) SWIG_fail;
7637 {
7638 PyThreadState* __tstate = wxPyBeginAllowThreads();
7639 result = (bool)(arg1)->eof();
7640
7641 wxPyEndAllowThreads(__tstate);
7642 if (PyErr_Occurred()) SWIG_fail;
7643 }
7644 {
7645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7646 }
7647 return resultobj;
7648 fail:
7649 return NULL;
7650 }
7651
7652
7653 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7654 PyObject *resultobj = NULL;
7655 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7656 int arg2 = (int) -1 ;
7657 PyObject *result;
7658 PyObject * obj0 = 0 ;
7659 PyObject * obj1 = 0 ;
7660 char *kwnames[] = {
7661 (char *) "self",(char *) "size", NULL
7662 };
7663
7664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7666 if (SWIG_arg_fail(1)) SWIG_fail;
7667 if (obj1) {
7668 {
7669 arg2 = static_cast<int >(SWIG_As_int(obj1));
7670 if (SWIG_arg_fail(2)) SWIG_fail;
7671 }
7672 }
7673 {
7674 PyThreadState* __tstate = wxPyBeginAllowThreads();
7675 result = (PyObject *)(arg1)->read(arg2);
7676
7677 wxPyEndAllowThreads(__tstate);
7678 if (PyErr_Occurred()) SWIG_fail;
7679 }
7680 resultobj = result;
7681 return resultobj;
7682 fail:
7683 return NULL;
7684 }
7685
7686
7687 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7688 PyObject *resultobj = NULL;
7689 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7690 int arg2 = (int) -1 ;
7691 PyObject *result;
7692 PyObject * obj0 = 0 ;
7693 PyObject * obj1 = 0 ;
7694 char *kwnames[] = {
7695 (char *) "self",(char *) "size", NULL
7696 };
7697
7698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7700 if (SWIG_arg_fail(1)) SWIG_fail;
7701 if (obj1) {
7702 {
7703 arg2 = static_cast<int >(SWIG_As_int(obj1));
7704 if (SWIG_arg_fail(2)) SWIG_fail;
7705 }
7706 }
7707 {
7708 PyThreadState* __tstate = wxPyBeginAllowThreads();
7709 result = (PyObject *)(arg1)->readline(arg2);
7710
7711 wxPyEndAllowThreads(__tstate);
7712 if (PyErr_Occurred()) SWIG_fail;
7713 }
7714 resultobj = result;
7715 return resultobj;
7716 fail:
7717 return NULL;
7718 }
7719
7720
7721 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7722 PyObject *resultobj = NULL;
7723 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7724 int arg2 = (int) -1 ;
7725 PyObject *result;
7726 PyObject * obj0 = 0 ;
7727 PyObject * obj1 = 0 ;
7728 char *kwnames[] = {
7729 (char *) "self",(char *) "sizehint", NULL
7730 };
7731
7732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7734 if (SWIG_arg_fail(1)) SWIG_fail;
7735 if (obj1) {
7736 {
7737 arg2 = static_cast<int >(SWIG_As_int(obj1));
7738 if (SWIG_arg_fail(2)) SWIG_fail;
7739 }
7740 }
7741 {
7742 PyThreadState* __tstate = wxPyBeginAllowThreads();
7743 result = (PyObject *)(arg1)->readlines(arg2);
7744
7745 wxPyEndAllowThreads(__tstate);
7746 if (PyErr_Occurred()) SWIG_fail;
7747 }
7748 resultobj = result;
7749 return resultobj;
7750 fail:
7751 return NULL;
7752 }
7753
7754
7755 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7756 PyObject *resultobj = NULL;
7757 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7758 int arg2 ;
7759 int arg3 = (int) 0 ;
7760 PyObject * obj0 = 0 ;
7761 PyObject * obj1 = 0 ;
7762 PyObject * obj2 = 0 ;
7763 char *kwnames[] = {
7764 (char *) "self",(char *) "offset",(char *) "whence", NULL
7765 };
7766
7767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7769 if (SWIG_arg_fail(1)) SWIG_fail;
7770 {
7771 arg2 = static_cast<int >(SWIG_As_int(obj1));
7772 if (SWIG_arg_fail(2)) SWIG_fail;
7773 }
7774 if (obj2) {
7775 {
7776 arg3 = static_cast<int >(SWIG_As_int(obj2));
7777 if (SWIG_arg_fail(3)) SWIG_fail;
7778 }
7779 }
7780 {
7781 PyThreadState* __tstate = wxPyBeginAllowThreads();
7782 (arg1)->seek(arg2,arg3);
7783
7784 wxPyEndAllowThreads(__tstate);
7785 if (PyErr_Occurred()) SWIG_fail;
7786 }
7787 Py_INCREF(Py_None); resultobj = Py_None;
7788 return resultobj;
7789 fail:
7790 return NULL;
7791 }
7792
7793
7794 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7795 PyObject *resultobj = NULL;
7796 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7797 int result;
7798 PyObject * obj0 = 0 ;
7799 char *kwnames[] = {
7800 (char *) "self", NULL
7801 };
7802
7803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7805 if (SWIG_arg_fail(1)) SWIG_fail;
7806 {
7807 PyThreadState* __tstate = wxPyBeginAllowThreads();
7808 result = (int)(arg1)->tell();
7809
7810 wxPyEndAllowThreads(__tstate);
7811 if (PyErr_Occurred()) SWIG_fail;
7812 }
7813 {
7814 resultobj = SWIG_From_int(static_cast<int >(result));
7815 }
7816 return resultobj;
7817 fail:
7818 return NULL;
7819 }
7820
7821
7822 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7823 PyObject *resultobj = NULL;
7824 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7825 char result;
7826 PyObject * obj0 = 0 ;
7827 char *kwnames[] = {
7828 (char *) "self", NULL
7829 };
7830
7831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7833 if (SWIG_arg_fail(1)) SWIG_fail;
7834 {
7835 PyThreadState* __tstate = wxPyBeginAllowThreads();
7836 result = (char)(arg1)->Peek();
7837
7838 wxPyEndAllowThreads(__tstate);
7839 if (PyErr_Occurred()) SWIG_fail;
7840 }
7841 {
7842 resultobj = SWIG_From_char(static_cast<char >(result));
7843 }
7844 return resultobj;
7845 fail:
7846 return NULL;
7847 }
7848
7849
7850 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7851 PyObject *resultobj = NULL;
7852 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7853 char result;
7854 PyObject * obj0 = 0 ;
7855 char *kwnames[] = {
7856 (char *) "self", NULL
7857 };
7858
7859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7861 if (SWIG_arg_fail(1)) SWIG_fail;
7862 {
7863 PyThreadState* __tstate = wxPyBeginAllowThreads();
7864 result = (char)(arg1)->GetC();
7865
7866 wxPyEndAllowThreads(__tstate);
7867 if (PyErr_Occurred()) SWIG_fail;
7868 }
7869 {
7870 resultobj = SWIG_From_char(static_cast<char >(result));
7871 }
7872 return resultobj;
7873 fail:
7874 return NULL;
7875 }
7876
7877
7878 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7879 PyObject *resultobj = NULL;
7880 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7881 size_t result;
7882 PyObject * obj0 = 0 ;
7883 char *kwnames[] = {
7884 (char *) "self", NULL
7885 };
7886
7887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7889 if (SWIG_arg_fail(1)) SWIG_fail;
7890 {
7891 PyThreadState* __tstate = wxPyBeginAllowThreads();
7892 result = (size_t)(arg1)->LastRead();
7893
7894 wxPyEndAllowThreads(__tstate);
7895 if (PyErr_Occurred()) SWIG_fail;
7896 }
7897 {
7898 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
7899 }
7900 return resultobj;
7901 fail:
7902 return NULL;
7903 }
7904
7905
7906 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7907 PyObject *resultobj = NULL;
7908 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7909 bool result;
7910 PyObject * obj0 = 0 ;
7911 char *kwnames[] = {
7912 (char *) "self", NULL
7913 };
7914
7915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7917 if (SWIG_arg_fail(1)) SWIG_fail;
7918 {
7919 PyThreadState* __tstate = wxPyBeginAllowThreads();
7920 result = (bool)(arg1)->CanRead();
7921
7922 wxPyEndAllowThreads(__tstate);
7923 if (PyErr_Occurred()) SWIG_fail;
7924 }
7925 {
7926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7927 }
7928 return resultobj;
7929 fail:
7930 return NULL;
7931 }
7932
7933
7934 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7935 PyObject *resultobj = NULL;
7936 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7937 bool result;
7938 PyObject * obj0 = 0 ;
7939 char *kwnames[] = {
7940 (char *) "self", NULL
7941 };
7942
7943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7945 if (SWIG_arg_fail(1)) SWIG_fail;
7946 {
7947 PyThreadState* __tstate = wxPyBeginAllowThreads();
7948 result = (bool)(arg1)->Eof();
7949
7950 wxPyEndAllowThreads(__tstate);
7951 if (PyErr_Occurred()) SWIG_fail;
7952 }
7953 {
7954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7955 }
7956 return resultobj;
7957 fail:
7958 return NULL;
7959 }
7960
7961
7962 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7963 PyObject *resultobj = NULL;
7964 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7965 char arg2 ;
7966 bool result;
7967 PyObject * obj0 = 0 ;
7968 PyObject * obj1 = 0 ;
7969 char *kwnames[] = {
7970 (char *) "self",(char *) "c", NULL
7971 };
7972
7973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7975 if (SWIG_arg_fail(1)) SWIG_fail;
7976 {
7977 arg2 = static_cast<char >(SWIG_As_char(obj1));
7978 if (SWIG_arg_fail(2)) SWIG_fail;
7979 }
7980 {
7981 PyThreadState* __tstate = wxPyBeginAllowThreads();
7982 result = (bool)(arg1)->Ungetch(arg2);
7983
7984 wxPyEndAllowThreads(__tstate);
7985 if (PyErr_Occurred()) SWIG_fail;
7986 }
7987 {
7988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7989 }
7990 return resultobj;
7991 fail:
7992 return NULL;
7993 }
7994
7995
7996 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7997 PyObject *resultobj = NULL;
7998 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7999 long arg2 ;
8000 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
8001 long result;
8002 PyObject * obj0 = 0 ;
8003 PyObject * obj1 = 0 ;
8004 PyObject * obj2 = 0 ;
8005 char *kwnames[] = {
8006 (char *) "self",(char *) "pos",(char *) "mode", NULL
8007 };
8008
8009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
8010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
8011 if (SWIG_arg_fail(1)) SWIG_fail;
8012 {
8013 arg2 = static_cast<long >(SWIG_As_long(obj1));
8014 if (SWIG_arg_fail(2)) SWIG_fail;
8015 }
8016 if (obj2) {
8017 {
8018 arg3 = static_cast<wxSeekMode >(SWIG_As_int(obj2));
8019 if (SWIG_arg_fail(3)) SWIG_fail;
8020 }
8021 }
8022 {
8023 PyThreadState* __tstate = wxPyBeginAllowThreads();
8024 result = (long)(arg1)->SeekI(arg2,arg3);
8025
8026 wxPyEndAllowThreads(__tstate);
8027 if (PyErr_Occurred()) SWIG_fail;
8028 }
8029 {
8030 resultobj = SWIG_From_long(static_cast<long >(result));
8031 }
8032 return resultobj;
8033 fail:
8034 return NULL;
8035 }
8036
8037
8038 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
8039 PyObject *resultobj = NULL;
8040 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8041 long result;
8042 PyObject * obj0 = 0 ;
8043 char *kwnames[] = {
8044 (char *) "self", NULL
8045 };
8046
8047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
8048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
8049 if (SWIG_arg_fail(1)) SWIG_fail;
8050 {
8051 PyThreadState* __tstate = wxPyBeginAllowThreads();
8052 result = (long)(arg1)->TellI();
8053
8054 wxPyEndAllowThreads(__tstate);
8055 if (PyErr_Occurred()) SWIG_fail;
8056 }
8057 {
8058 resultobj = SWIG_From_long(static_cast<long >(result));
8059 }
8060 return resultobj;
8061 fail:
8062 return NULL;
8063 }
8064
8065
8066 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
8067 PyObject *obj;
8068 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8069 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
8070 Py_INCREF(obj);
8071 return Py_BuildValue((char *)"");
8072 }
8073 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
8074 PyObject *resultobj = NULL;
8075 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
8076 PyObject *arg2 = (PyObject *) 0 ;
8077 PyObject * obj0 = 0 ;
8078 PyObject * obj1 = 0 ;
8079 char *kwnames[] = {
8080 (char *) "self",(char *) "obj", NULL
8081 };
8082
8083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
8084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
8085 if (SWIG_arg_fail(1)) SWIG_fail;
8086 arg2 = obj1;
8087 {
8088 PyThreadState* __tstate = wxPyBeginAllowThreads();
8089 wxOutputStream_write(arg1,arg2);
8090
8091 wxPyEndAllowThreads(__tstate);
8092 if (PyErr_Occurred()) SWIG_fail;
8093 }
8094 Py_INCREF(Py_None); resultobj = Py_None;
8095 return resultobj;
8096 fail:
8097 return NULL;
8098 }
8099
8100
8101 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
8102 PyObject *obj;
8103 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8104 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
8105 Py_INCREF(obj);
8106 return Py_BuildValue((char *)"");
8107 }
8108 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8109 PyObject *resultobj = NULL;
8110 wxInputStream *arg1 = (wxInputStream *) 0 ;
8111 wxString *arg2 = 0 ;
8112 wxString *arg3 = 0 ;
8113 wxString *arg4 = 0 ;
8114 wxDateTime arg5 ;
8115 wxFSFile *result;
8116 wxPyInputStream *temp1 ;
8117 bool temp2 = false ;
8118 bool temp3 = false ;
8119 bool temp4 = false ;
8120 PyObject * obj0 = 0 ;
8121 PyObject * obj1 = 0 ;
8122 PyObject * obj2 = 0 ;
8123 PyObject * obj3 = 0 ;
8124 PyObject * obj4 = 0 ;
8125 char *kwnames[] = {
8126 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
8127 };
8128
8129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
8130 {
8131 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
8132 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
8133 } else {
8134 PyErr_Clear(); // clear the failure of the wxPyConvert above
8135 arg1 = wxPyCBInputStream_create(obj0, true);
8136 if (arg1 == NULL) {
8137 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
8138 SWIG_fail;
8139 }
8140 }
8141 }
8142 {
8143 arg2 = wxString_in_helper(obj1);
8144 if (arg2 == NULL) SWIG_fail;
8145 temp2 = true;
8146 }
8147 {
8148 arg3 = wxString_in_helper(obj2);
8149 if (arg3 == NULL) SWIG_fail;
8150 temp3 = true;
8151 }
8152 {
8153 arg4 = wxString_in_helper(obj3);
8154 if (arg4 == NULL) SWIG_fail;
8155 temp4 = true;
8156 }
8157 {
8158 wxDateTime * argp;
8159 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8160 if (SWIG_arg_fail(5)) SWIG_fail;
8161 if (argp == NULL) {
8162 SWIG_null_ref("wxDateTime");
8163 }
8164 if (SWIG_arg_fail(5)) SWIG_fail;
8165 arg5 = *argp;
8166 }
8167 {
8168 PyThreadState* __tstate = wxPyBeginAllowThreads();
8169 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8170
8171 wxPyEndAllowThreads(__tstate);
8172 if (PyErr_Occurred()) SWIG_fail;
8173 }
8174 {
8175 resultobj = wxPyMake_wxObject(result, (bool)1);
8176 }
8177 {
8178 if (temp2)
8179 delete arg2;
8180 }
8181 {
8182 if (temp3)
8183 delete arg3;
8184 }
8185 {
8186 if (temp4)
8187 delete arg4;
8188 }
8189 return resultobj;
8190 fail:
8191 {
8192 if (temp2)
8193 delete arg2;
8194 }
8195 {
8196 if (temp3)
8197 delete arg3;
8198 }
8199 {
8200 if (temp4)
8201 delete arg4;
8202 }
8203 return NULL;
8204 }
8205
8206
8207 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8208 PyObject *resultobj = NULL;
8209 wxFSFile *arg1 = (wxFSFile *) 0 ;
8210 PyObject * obj0 = 0 ;
8211 char *kwnames[] = {
8212 (char *) "self", NULL
8213 };
8214
8215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8217 if (SWIG_arg_fail(1)) SWIG_fail;
8218 {
8219 PyThreadState* __tstate = wxPyBeginAllowThreads();
8220 delete arg1;
8221
8222 wxPyEndAllowThreads(__tstate);
8223 if (PyErr_Occurred()) SWIG_fail;
8224 }
8225 Py_INCREF(Py_None); resultobj = Py_None;
8226 return resultobj;
8227 fail:
8228 return NULL;
8229 }
8230
8231
8232 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8233 PyObject *resultobj = NULL;
8234 wxFSFile *arg1 = (wxFSFile *) 0 ;
8235 wxInputStream *result;
8236 PyObject * obj0 = 0 ;
8237 char *kwnames[] = {
8238 (char *) "self", NULL
8239 };
8240
8241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8243 if (SWIG_arg_fail(1)) SWIG_fail;
8244 {
8245 PyThreadState* __tstate = wxPyBeginAllowThreads();
8246 result = (wxInputStream *)(arg1)->GetStream();
8247
8248 wxPyEndAllowThreads(__tstate);
8249 if (PyErr_Occurred()) SWIG_fail;
8250 }
8251 {
8252 wxPyInputStream * _ptr = NULL;
8253
8254 if (result) {
8255 _ptr = new wxPyInputStream(result);
8256 }
8257 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8258 }
8259 return resultobj;
8260 fail:
8261 return NULL;
8262 }
8263
8264
8265 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8266 PyObject *resultobj = NULL;
8267 wxFSFile *arg1 = (wxFSFile *) 0 ;
8268 wxString *result;
8269 PyObject * obj0 = 0 ;
8270 char *kwnames[] = {
8271 (char *) "self", NULL
8272 };
8273
8274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8276 if (SWIG_arg_fail(1)) SWIG_fail;
8277 {
8278 PyThreadState* __tstate = wxPyBeginAllowThreads();
8279 {
8280 wxString const &_result_ref = (arg1)->GetMimeType();
8281 result = (wxString *) &_result_ref;
8282 }
8283
8284 wxPyEndAllowThreads(__tstate);
8285 if (PyErr_Occurred()) SWIG_fail;
8286 }
8287 {
8288 #if wxUSE_UNICODE
8289 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8290 #else
8291 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8292 #endif
8293 }
8294 return resultobj;
8295 fail:
8296 return NULL;
8297 }
8298
8299
8300 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8301 PyObject *resultobj = NULL;
8302 wxFSFile *arg1 = (wxFSFile *) 0 ;
8303 wxString *result;
8304 PyObject * obj0 = 0 ;
8305 char *kwnames[] = {
8306 (char *) "self", NULL
8307 };
8308
8309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8311 if (SWIG_arg_fail(1)) SWIG_fail;
8312 {
8313 PyThreadState* __tstate = wxPyBeginAllowThreads();
8314 {
8315 wxString const &_result_ref = (arg1)->GetLocation();
8316 result = (wxString *) &_result_ref;
8317 }
8318
8319 wxPyEndAllowThreads(__tstate);
8320 if (PyErr_Occurred()) SWIG_fail;
8321 }
8322 {
8323 #if wxUSE_UNICODE
8324 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8325 #else
8326 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8327 #endif
8328 }
8329 return resultobj;
8330 fail:
8331 return NULL;
8332 }
8333
8334
8335 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8336 PyObject *resultobj = NULL;
8337 wxFSFile *arg1 = (wxFSFile *) 0 ;
8338 wxString *result;
8339 PyObject * obj0 = 0 ;
8340 char *kwnames[] = {
8341 (char *) "self", NULL
8342 };
8343
8344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8346 if (SWIG_arg_fail(1)) SWIG_fail;
8347 {
8348 PyThreadState* __tstate = wxPyBeginAllowThreads();
8349 {
8350 wxString const &_result_ref = (arg1)->GetAnchor();
8351 result = (wxString *) &_result_ref;
8352 }
8353
8354 wxPyEndAllowThreads(__tstate);
8355 if (PyErr_Occurred()) SWIG_fail;
8356 }
8357 {
8358 #if wxUSE_UNICODE
8359 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8360 #else
8361 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8362 #endif
8363 }
8364 return resultobj;
8365 fail:
8366 return NULL;
8367 }
8368
8369
8370 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8371 PyObject *resultobj = NULL;
8372 wxFSFile *arg1 = (wxFSFile *) 0 ;
8373 wxDateTime result;
8374 PyObject * obj0 = 0 ;
8375 char *kwnames[] = {
8376 (char *) "self", NULL
8377 };
8378
8379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8381 if (SWIG_arg_fail(1)) SWIG_fail;
8382 {
8383 PyThreadState* __tstate = wxPyBeginAllowThreads();
8384 result = (arg1)->GetModificationTime();
8385
8386 wxPyEndAllowThreads(__tstate);
8387 if (PyErr_Occurred()) SWIG_fail;
8388 }
8389 {
8390 wxDateTime * resultptr;
8391 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
8392 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8393 }
8394 return resultobj;
8395 fail:
8396 return NULL;
8397 }
8398
8399
8400 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8401 PyObject *obj;
8402 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8403 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8404 Py_INCREF(obj);
8405 return Py_BuildValue((char *)"");
8406 }
8407 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8408 PyObject *obj;
8409 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8410 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8411 Py_INCREF(obj);
8412 return Py_BuildValue((char *)"");
8413 }
8414 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8415 PyObject *resultobj = NULL;
8416 wxPyFileSystemHandler *result;
8417 char *kwnames[] = {
8418 NULL
8419 };
8420
8421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8422 {
8423 PyThreadState* __tstate = wxPyBeginAllowThreads();
8424 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8425
8426 wxPyEndAllowThreads(__tstate);
8427 if (PyErr_Occurred()) SWIG_fail;
8428 }
8429 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8430 return resultobj;
8431 fail:
8432 return NULL;
8433 }
8434
8435
8436 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8437 PyObject *resultobj = NULL;
8438 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8439 PyObject *arg2 = (PyObject *) 0 ;
8440 PyObject *arg3 = (PyObject *) 0 ;
8441 PyObject * obj0 = 0 ;
8442 PyObject * obj1 = 0 ;
8443 PyObject * obj2 = 0 ;
8444 char *kwnames[] = {
8445 (char *) "self",(char *) "self",(char *) "_class", NULL
8446 };
8447
8448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8450 if (SWIG_arg_fail(1)) SWIG_fail;
8451 arg2 = obj1;
8452 arg3 = obj2;
8453 {
8454 PyThreadState* __tstate = wxPyBeginAllowThreads();
8455 (arg1)->_setCallbackInfo(arg2,arg3);
8456
8457 wxPyEndAllowThreads(__tstate);
8458 if (PyErr_Occurred()) SWIG_fail;
8459 }
8460 Py_INCREF(Py_None); resultobj = Py_None;
8461 return resultobj;
8462 fail:
8463 return NULL;
8464 }
8465
8466
8467 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8468 PyObject *resultobj = NULL;
8469 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8470 wxString *arg2 = 0 ;
8471 bool result;
8472 bool temp2 = false ;
8473 PyObject * obj0 = 0 ;
8474 PyObject * obj1 = 0 ;
8475 char *kwnames[] = {
8476 (char *) "self",(char *) "location", NULL
8477 };
8478
8479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8481 if (SWIG_arg_fail(1)) SWIG_fail;
8482 {
8483 arg2 = wxString_in_helper(obj1);
8484 if (arg2 == NULL) SWIG_fail;
8485 temp2 = true;
8486 }
8487 {
8488 PyThreadState* __tstate = wxPyBeginAllowThreads();
8489 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8490
8491 wxPyEndAllowThreads(__tstate);
8492 if (PyErr_Occurred()) SWIG_fail;
8493 }
8494 {
8495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8496 }
8497 {
8498 if (temp2)
8499 delete arg2;
8500 }
8501 return resultobj;
8502 fail:
8503 {
8504 if (temp2)
8505 delete arg2;
8506 }
8507 return NULL;
8508 }
8509
8510
8511 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8512 PyObject *resultobj = NULL;
8513 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8514 wxFileSystem *arg2 = 0 ;
8515 wxString *arg3 = 0 ;
8516 wxFSFile *result;
8517 bool temp3 = false ;
8518 PyObject * obj0 = 0 ;
8519 PyObject * obj1 = 0 ;
8520 PyObject * obj2 = 0 ;
8521 char *kwnames[] = {
8522 (char *) "self",(char *) "fs",(char *) "location", NULL
8523 };
8524
8525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8527 if (SWIG_arg_fail(1)) SWIG_fail;
8528 {
8529 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8530 if (SWIG_arg_fail(2)) SWIG_fail;
8531 if (arg2 == NULL) {
8532 SWIG_null_ref("wxFileSystem");
8533 }
8534 if (SWIG_arg_fail(2)) SWIG_fail;
8535 }
8536 {
8537 arg3 = wxString_in_helper(obj2);
8538 if (arg3 == NULL) SWIG_fail;
8539 temp3 = true;
8540 }
8541 {
8542 PyThreadState* __tstate = wxPyBeginAllowThreads();
8543 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8544
8545 wxPyEndAllowThreads(__tstate);
8546 if (PyErr_Occurred()) SWIG_fail;
8547 }
8548 {
8549 resultobj = wxPyMake_wxObject(result, (bool)1);
8550 }
8551 {
8552 if (temp3)
8553 delete arg3;
8554 }
8555 return resultobj;
8556 fail:
8557 {
8558 if (temp3)
8559 delete arg3;
8560 }
8561 return NULL;
8562 }
8563
8564
8565 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8566 PyObject *resultobj = NULL;
8567 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8568 wxString *arg2 = 0 ;
8569 int arg3 = (int) 0 ;
8570 wxString result;
8571 bool temp2 = false ;
8572 PyObject * obj0 = 0 ;
8573 PyObject * obj1 = 0 ;
8574 PyObject * obj2 = 0 ;
8575 char *kwnames[] = {
8576 (char *) "self",(char *) "spec",(char *) "flags", NULL
8577 };
8578
8579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8581 if (SWIG_arg_fail(1)) SWIG_fail;
8582 {
8583 arg2 = wxString_in_helper(obj1);
8584 if (arg2 == NULL) SWIG_fail;
8585 temp2 = true;
8586 }
8587 if (obj2) {
8588 {
8589 arg3 = static_cast<int >(SWIG_As_int(obj2));
8590 if (SWIG_arg_fail(3)) SWIG_fail;
8591 }
8592 }
8593 {
8594 PyThreadState* __tstate = wxPyBeginAllowThreads();
8595 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8596
8597 wxPyEndAllowThreads(__tstate);
8598 if (PyErr_Occurred()) SWIG_fail;
8599 }
8600 {
8601 #if wxUSE_UNICODE
8602 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8603 #else
8604 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8605 #endif
8606 }
8607 {
8608 if (temp2)
8609 delete arg2;
8610 }
8611 return resultobj;
8612 fail:
8613 {
8614 if (temp2)
8615 delete arg2;
8616 }
8617 return NULL;
8618 }
8619
8620
8621 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8622 PyObject *resultobj = NULL;
8623 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8624 wxString result;
8625 PyObject * obj0 = 0 ;
8626 char *kwnames[] = {
8627 (char *) "self", NULL
8628 };
8629
8630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8632 if (SWIG_arg_fail(1)) SWIG_fail;
8633 {
8634 PyThreadState* __tstate = wxPyBeginAllowThreads();
8635 result = (arg1)->FindNext();
8636
8637 wxPyEndAllowThreads(__tstate);
8638 if (PyErr_Occurred()) SWIG_fail;
8639 }
8640 {
8641 #if wxUSE_UNICODE
8642 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8643 #else
8644 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8645 #endif
8646 }
8647 return resultobj;
8648 fail:
8649 return NULL;
8650 }
8651
8652
8653 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8654 PyObject *resultobj = NULL;
8655 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8656 wxString *arg2 = 0 ;
8657 wxString result;
8658 bool temp2 = false ;
8659 PyObject * obj0 = 0 ;
8660 PyObject * obj1 = 0 ;
8661 char *kwnames[] = {
8662 (char *) "self",(char *) "location", NULL
8663 };
8664
8665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8667 if (SWIG_arg_fail(1)) SWIG_fail;
8668 {
8669 arg2 = wxString_in_helper(obj1);
8670 if (arg2 == NULL) SWIG_fail;
8671 temp2 = true;
8672 }
8673 {
8674 PyThreadState* __tstate = wxPyBeginAllowThreads();
8675 result = (arg1)->GetProtocol((wxString const &)*arg2);
8676
8677 wxPyEndAllowThreads(__tstate);
8678 if (PyErr_Occurred()) SWIG_fail;
8679 }
8680 {
8681 #if wxUSE_UNICODE
8682 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8683 #else
8684 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8685 #endif
8686 }
8687 {
8688 if (temp2)
8689 delete arg2;
8690 }
8691 return resultobj;
8692 fail:
8693 {
8694 if (temp2)
8695 delete arg2;
8696 }
8697 return NULL;
8698 }
8699
8700
8701 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8702 PyObject *resultobj = NULL;
8703 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8704 wxString *arg2 = 0 ;
8705 wxString result;
8706 bool temp2 = false ;
8707 PyObject * obj0 = 0 ;
8708 PyObject * obj1 = 0 ;
8709 char *kwnames[] = {
8710 (char *) "self",(char *) "location", NULL
8711 };
8712
8713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8715 if (SWIG_arg_fail(1)) SWIG_fail;
8716 {
8717 arg2 = wxString_in_helper(obj1);
8718 if (arg2 == NULL) SWIG_fail;
8719 temp2 = true;
8720 }
8721 {
8722 PyThreadState* __tstate = wxPyBeginAllowThreads();
8723 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8724
8725 wxPyEndAllowThreads(__tstate);
8726 if (PyErr_Occurred()) SWIG_fail;
8727 }
8728 {
8729 #if wxUSE_UNICODE
8730 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8731 #else
8732 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8733 #endif
8734 }
8735 {
8736 if (temp2)
8737 delete arg2;
8738 }
8739 return resultobj;
8740 fail:
8741 {
8742 if (temp2)
8743 delete arg2;
8744 }
8745 return NULL;
8746 }
8747
8748
8749 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8750 PyObject *resultobj = NULL;
8751 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8752 wxString *arg2 = 0 ;
8753 wxString result;
8754 bool temp2 = false ;
8755 PyObject * obj0 = 0 ;
8756 PyObject * obj1 = 0 ;
8757 char *kwnames[] = {
8758 (char *) "self",(char *) "location", NULL
8759 };
8760
8761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8763 if (SWIG_arg_fail(1)) SWIG_fail;
8764 {
8765 arg2 = wxString_in_helper(obj1);
8766 if (arg2 == NULL) SWIG_fail;
8767 temp2 = true;
8768 }
8769 {
8770 PyThreadState* __tstate = wxPyBeginAllowThreads();
8771 result = (arg1)->GetAnchor((wxString const &)*arg2);
8772
8773 wxPyEndAllowThreads(__tstate);
8774 if (PyErr_Occurred()) SWIG_fail;
8775 }
8776 {
8777 #if wxUSE_UNICODE
8778 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8779 #else
8780 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8781 #endif
8782 }
8783 {
8784 if (temp2)
8785 delete arg2;
8786 }
8787 return resultobj;
8788 fail:
8789 {
8790 if (temp2)
8791 delete arg2;
8792 }
8793 return NULL;
8794 }
8795
8796
8797 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8798 PyObject *resultobj = NULL;
8799 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8800 wxString *arg2 = 0 ;
8801 wxString result;
8802 bool temp2 = false ;
8803 PyObject * obj0 = 0 ;
8804 PyObject * obj1 = 0 ;
8805 char *kwnames[] = {
8806 (char *) "self",(char *) "location", NULL
8807 };
8808
8809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8811 if (SWIG_arg_fail(1)) SWIG_fail;
8812 {
8813 arg2 = wxString_in_helper(obj1);
8814 if (arg2 == NULL) SWIG_fail;
8815 temp2 = true;
8816 }
8817 {
8818 PyThreadState* __tstate = wxPyBeginAllowThreads();
8819 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8820
8821 wxPyEndAllowThreads(__tstate);
8822 if (PyErr_Occurred()) SWIG_fail;
8823 }
8824 {
8825 #if wxUSE_UNICODE
8826 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8827 #else
8828 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8829 #endif
8830 }
8831 {
8832 if (temp2)
8833 delete arg2;
8834 }
8835 return resultobj;
8836 fail:
8837 {
8838 if (temp2)
8839 delete arg2;
8840 }
8841 return NULL;
8842 }
8843
8844
8845 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8846 PyObject *resultobj = NULL;
8847 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8848 wxString *arg2 = 0 ;
8849 wxString result;
8850 bool temp2 = false ;
8851 PyObject * obj0 = 0 ;
8852 PyObject * obj1 = 0 ;
8853 char *kwnames[] = {
8854 (char *) "self",(char *) "location", NULL
8855 };
8856
8857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8859 if (SWIG_arg_fail(1)) SWIG_fail;
8860 {
8861 arg2 = wxString_in_helper(obj1);
8862 if (arg2 == NULL) SWIG_fail;
8863 temp2 = true;
8864 }
8865 {
8866 PyThreadState* __tstate = wxPyBeginAllowThreads();
8867 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8868
8869 wxPyEndAllowThreads(__tstate);
8870 if (PyErr_Occurred()) SWIG_fail;
8871 }
8872 {
8873 #if wxUSE_UNICODE
8874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8875 #else
8876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8877 #endif
8878 }
8879 {
8880 if (temp2)
8881 delete arg2;
8882 }
8883 return resultobj;
8884 fail:
8885 {
8886 if (temp2)
8887 delete arg2;
8888 }
8889 return NULL;
8890 }
8891
8892
8893 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8894 PyObject *obj;
8895 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8896 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8897 Py_INCREF(obj);
8898 return Py_BuildValue((char *)"");
8899 }
8900 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8901 PyObject *resultobj = NULL;
8902 wxFileSystem *result;
8903 char *kwnames[] = {
8904 NULL
8905 };
8906
8907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8908 {
8909 PyThreadState* __tstate = wxPyBeginAllowThreads();
8910 result = (wxFileSystem *)new wxFileSystem();
8911
8912 wxPyEndAllowThreads(__tstate);
8913 if (PyErr_Occurred()) SWIG_fail;
8914 }
8915 {
8916 resultobj = wxPyMake_wxObject(result, (bool)1);
8917 }
8918 return resultobj;
8919 fail:
8920 return NULL;
8921 }
8922
8923
8924 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8925 PyObject *resultobj = NULL;
8926 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8927 PyObject * obj0 = 0 ;
8928 char *kwnames[] = {
8929 (char *) "self", NULL
8930 };
8931
8932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8934 if (SWIG_arg_fail(1)) SWIG_fail;
8935 {
8936 PyThreadState* __tstate = wxPyBeginAllowThreads();
8937 delete arg1;
8938
8939 wxPyEndAllowThreads(__tstate);
8940 if (PyErr_Occurred()) SWIG_fail;
8941 }
8942 Py_INCREF(Py_None); resultobj = Py_None;
8943 return resultobj;
8944 fail:
8945 return NULL;
8946 }
8947
8948
8949 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8950 PyObject *resultobj = NULL;
8951 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8952 wxString *arg2 = 0 ;
8953 bool arg3 = (bool) false ;
8954 bool temp2 = false ;
8955 PyObject * obj0 = 0 ;
8956 PyObject * obj1 = 0 ;
8957 PyObject * obj2 = 0 ;
8958 char *kwnames[] = {
8959 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8960 };
8961
8962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8964 if (SWIG_arg_fail(1)) SWIG_fail;
8965 {
8966 arg2 = wxString_in_helper(obj1);
8967 if (arg2 == NULL) SWIG_fail;
8968 temp2 = true;
8969 }
8970 if (obj2) {
8971 {
8972 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
8973 if (SWIG_arg_fail(3)) SWIG_fail;
8974 }
8975 }
8976 {
8977 PyThreadState* __tstate = wxPyBeginAllowThreads();
8978 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8979
8980 wxPyEndAllowThreads(__tstate);
8981 if (PyErr_Occurred()) SWIG_fail;
8982 }
8983 Py_INCREF(Py_None); resultobj = Py_None;
8984 {
8985 if (temp2)
8986 delete arg2;
8987 }
8988 return resultobj;
8989 fail:
8990 {
8991 if (temp2)
8992 delete arg2;
8993 }
8994 return NULL;
8995 }
8996
8997
8998 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8999 PyObject *resultobj = NULL;
9000 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9001 wxString result;
9002 PyObject * obj0 = 0 ;
9003 char *kwnames[] = {
9004 (char *) "self", NULL
9005 };
9006
9007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
9008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9009 if (SWIG_arg_fail(1)) SWIG_fail;
9010 {
9011 PyThreadState* __tstate = wxPyBeginAllowThreads();
9012 result = (arg1)->GetPath();
9013
9014 wxPyEndAllowThreads(__tstate);
9015 if (PyErr_Occurred()) SWIG_fail;
9016 }
9017 {
9018 #if wxUSE_UNICODE
9019 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9020 #else
9021 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9022 #endif
9023 }
9024 return resultobj;
9025 fail:
9026 return NULL;
9027 }
9028
9029
9030 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9031 PyObject *resultobj = NULL;
9032 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9033 wxString *arg2 = 0 ;
9034 wxFSFile *result;
9035 bool temp2 = false ;
9036 PyObject * obj0 = 0 ;
9037 PyObject * obj1 = 0 ;
9038 char *kwnames[] = {
9039 (char *) "self",(char *) "location", NULL
9040 };
9041
9042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
9043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9044 if (SWIG_arg_fail(1)) SWIG_fail;
9045 {
9046 arg2 = wxString_in_helper(obj1);
9047 if (arg2 == NULL) SWIG_fail;
9048 temp2 = true;
9049 }
9050 {
9051 PyThreadState* __tstate = wxPyBeginAllowThreads();
9052 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
9053
9054 wxPyEndAllowThreads(__tstate);
9055 if (PyErr_Occurred()) SWIG_fail;
9056 }
9057 {
9058 resultobj = wxPyMake_wxObject(result, (bool)1);
9059 }
9060 {
9061 if (temp2)
9062 delete arg2;
9063 }
9064 return resultobj;
9065 fail:
9066 {
9067 if (temp2)
9068 delete arg2;
9069 }
9070 return NULL;
9071 }
9072
9073
9074 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9075 PyObject *resultobj = NULL;
9076 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9077 wxString *arg2 = 0 ;
9078 int arg3 = (int) 0 ;
9079 wxString result;
9080 bool temp2 = false ;
9081 PyObject * obj0 = 0 ;
9082 PyObject * obj1 = 0 ;
9083 PyObject * obj2 = 0 ;
9084 char *kwnames[] = {
9085 (char *) "self",(char *) "spec",(char *) "flags", NULL
9086 };
9087
9088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9090 if (SWIG_arg_fail(1)) SWIG_fail;
9091 {
9092 arg2 = wxString_in_helper(obj1);
9093 if (arg2 == NULL) SWIG_fail;
9094 temp2 = true;
9095 }
9096 if (obj2) {
9097 {
9098 arg3 = static_cast<int >(SWIG_As_int(obj2));
9099 if (SWIG_arg_fail(3)) SWIG_fail;
9100 }
9101 }
9102 {
9103 PyThreadState* __tstate = wxPyBeginAllowThreads();
9104 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9105
9106 wxPyEndAllowThreads(__tstate);
9107 if (PyErr_Occurred()) SWIG_fail;
9108 }
9109 {
9110 #if wxUSE_UNICODE
9111 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9112 #else
9113 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9114 #endif
9115 }
9116 {
9117 if (temp2)
9118 delete arg2;
9119 }
9120 return resultobj;
9121 fail:
9122 {
9123 if (temp2)
9124 delete arg2;
9125 }
9126 return NULL;
9127 }
9128
9129
9130 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9131 PyObject *resultobj = NULL;
9132 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9133 wxString result;
9134 PyObject * obj0 = 0 ;
9135 char *kwnames[] = {
9136 (char *) "self", NULL
9137 };
9138
9139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
9140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9141 if (SWIG_arg_fail(1)) SWIG_fail;
9142 {
9143 PyThreadState* __tstate = wxPyBeginAllowThreads();
9144 result = (arg1)->FindNext();
9145
9146 wxPyEndAllowThreads(__tstate);
9147 if (PyErr_Occurred()) SWIG_fail;
9148 }
9149 {
9150 #if wxUSE_UNICODE
9151 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9152 #else
9153 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9154 #endif
9155 }
9156 return resultobj;
9157 fail:
9158 return NULL;
9159 }
9160
9161
9162 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9163 PyObject *resultobj = NULL;
9164 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9165 PyObject * obj0 = 0 ;
9166 char *kwnames[] = {
9167 (char *) "handler", NULL
9168 };
9169
9170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9172 if (SWIG_arg_fail(1)) SWIG_fail;
9173 {
9174 PyThreadState* __tstate = wxPyBeginAllowThreads();
9175 wxFileSystem::AddHandler(arg1);
9176
9177 wxPyEndAllowThreads(__tstate);
9178 if (PyErr_Occurred()) SWIG_fail;
9179 }
9180 Py_INCREF(Py_None); resultobj = Py_None;
9181 return resultobj;
9182 fail:
9183 return NULL;
9184 }
9185
9186
9187 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9188 PyObject *resultobj = NULL;
9189 char *kwnames[] = {
9190 NULL
9191 };
9192
9193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9194 {
9195 PyThreadState* __tstate = wxPyBeginAllowThreads();
9196 wxFileSystem::CleanUpHandlers();
9197
9198 wxPyEndAllowThreads(__tstate);
9199 if (PyErr_Occurred()) SWIG_fail;
9200 }
9201 Py_INCREF(Py_None); resultobj = Py_None;
9202 return resultobj;
9203 fail:
9204 return NULL;
9205 }
9206
9207
9208 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9209 PyObject *resultobj = NULL;
9210 wxString *arg1 = 0 ;
9211 wxString result;
9212 bool temp1 = false ;
9213 PyObject * obj0 = 0 ;
9214 char *kwnames[] = {
9215 (char *) "filename", NULL
9216 };
9217
9218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9219 {
9220 arg1 = wxString_in_helper(obj0);
9221 if (arg1 == NULL) SWIG_fail;
9222 temp1 = true;
9223 }
9224 {
9225 PyThreadState* __tstate = wxPyBeginAllowThreads();
9226 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9227
9228 wxPyEndAllowThreads(__tstate);
9229 if (PyErr_Occurred()) SWIG_fail;
9230 }
9231 {
9232 #if wxUSE_UNICODE
9233 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9234 #else
9235 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9236 #endif
9237 }
9238 {
9239 if (temp1)
9240 delete arg1;
9241 }
9242 return resultobj;
9243 fail:
9244 {
9245 if (temp1)
9246 delete arg1;
9247 }
9248 return NULL;
9249 }
9250
9251
9252 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9253 PyObject *resultobj = NULL;
9254 wxString *arg1 = 0 ;
9255 wxString result;
9256 bool temp1 = false ;
9257 PyObject * obj0 = 0 ;
9258 char *kwnames[] = {
9259 (char *) "url", NULL
9260 };
9261
9262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9263 {
9264 arg1 = wxString_in_helper(obj0);
9265 if (arg1 == NULL) SWIG_fail;
9266 temp1 = true;
9267 }
9268 {
9269 PyThreadState* __tstate = wxPyBeginAllowThreads();
9270 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
9271
9272 wxPyEndAllowThreads(__tstate);
9273 if (PyErr_Occurred()) SWIG_fail;
9274 }
9275 {
9276 #if wxUSE_UNICODE
9277 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9278 #else
9279 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9280 #endif
9281 }
9282 {
9283 if (temp1)
9284 delete arg1;
9285 }
9286 return resultobj;
9287 fail:
9288 {
9289 if (temp1)
9290 delete arg1;
9291 }
9292 return NULL;
9293 }
9294
9295
9296 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9297 PyObject *obj;
9298 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9299 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9300 Py_INCREF(obj);
9301 return Py_BuildValue((char *)"");
9302 }
9303 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9304 PyObject *resultobj = NULL;
9305 wxInternetFSHandler *result;
9306 char *kwnames[] = {
9307 NULL
9308 };
9309
9310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9311 {
9312 PyThreadState* __tstate = wxPyBeginAllowThreads();
9313 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9314
9315 wxPyEndAllowThreads(__tstate);
9316 if (PyErr_Occurred()) SWIG_fail;
9317 }
9318 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9319 return resultobj;
9320 fail:
9321 return NULL;
9322 }
9323
9324
9325 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9326 PyObject *resultobj = NULL;
9327 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9328 wxString *arg2 = 0 ;
9329 bool result;
9330 bool temp2 = false ;
9331 PyObject * obj0 = 0 ;
9332 PyObject * obj1 = 0 ;
9333 char *kwnames[] = {
9334 (char *) "self",(char *) "location", NULL
9335 };
9336
9337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9339 if (SWIG_arg_fail(1)) SWIG_fail;
9340 {
9341 arg2 = wxString_in_helper(obj1);
9342 if (arg2 == NULL) SWIG_fail;
9343 temp2 = true;
9344 }
9345 {
9346 PyThreadState* __tstate = wxPyBeginAllowThreads();
9347 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9348
9349 wxPyEndAllowThreads(__tstate);
9350 if (PyErr_Occurred()) SWIG_fail;
9351 }
9352 {
9353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9354 }
9355 {
9356 if (temp2)
9357 delete arg2;
9358 }
9359 return resultobj;
9360 fail:
9361 {
9362 if (temp2)
9363 delete arg2;
9364 }
9365 return NULL;
9366 }
9367
9368
9369 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9370 PyObject *resultobj = NULL;
9371 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9372 wxFileSystem *arg2 = 0 ;
9373 wxString *arg3 = 0 ;
9374 wxFSFile *result;
9375 bool temp3 = false ;
9376 PyObject * obj0 = 0 ;
9377 PyObject * obj1 = 0 ;
9378 PyObject * obj2 = 0 ;
9379 char *kwnames[] = {
9380 (char *) "self",(char *) "fs",(char *) "location", NULL
9381 };
9382
9383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9385 if (SWIG_arg_fail(1)) SWIG_fail;
9386 {
9387 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9388 if (SWIG_arg_fail(2)) SWIG_fail;
9389 if (arg2 == NULL) {
9390 SWIG_null_ref("wxFileSystem");
9391 }
9392 if (SWIG_arg_fail(2)) SWIG_fail;
9393 }
9394 {
9395 arg3 = wxString_in_helper(obj2);
9396 if (arg3 == NULL) SWIG_fail;
9397 temp3 = true;
9398 }
9399 {
9400 PyThreadState* __tstate = wxPyBeginAllowThreads();
9401 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9402
9403 wxPyEndAllowThreads(__tstate);
9404 if (PyErr_Occurred()) SWIG_fail;
9405 }
9406 {
9407 resultobj = wxPyMake_wxObject(result, (bool)1);
9408 }
9409 {
9410 if (temp3)
9411 delete arg3;
9412 }
9413 return resultobj;
9414 fail:
9415 {
9416 if (temp3)
9417 delete arg3;
9418 }
9419 return NULL;
9420 }
9421
9422
9423 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9424 PyObject *obj;
9425 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9426 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9427 Py_INCREF(obj);
9428 return Py_BuildValue((char *)"");
9429 }
9430 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9431 PyObject *resultobj = NULL;
9432 wxZipFSHandler *result;
9433 char *kwnames[] = {
9434 NULL
9435 };
9436
9437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9438 {
9439 PyThreadState* __tstate = wxPyBeginAllowThreads();
9440 result = (wxZipFSHandler *)new wxZipFSHandler();
9441
9442 wxPyEndAllowThreads(__tstate);
9443 if (PyErr_Occurred()) SWIG_fail;
9444 }
9445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9446 return resultobj;
9447 fail:
9448 return NULL;
9449 }
9450
9451
9452 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9453 PyObject *resultobj = NULL;
9454 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9455 wxString *arg2 = 0 ;
9456 bool result;
9457 bool temp2 = false ;
9458 PyObject * obj0 = 0 ;
9459 PyObject * obj1 = 0 ;
9460 char *kwnames[] = {
9461 (char *) "self",(char *) "location", NULL
9462 };
9463
9464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9466 if (SWIG_arg_fail(1)) SWIG_fail;
9467 {
9468 arg2 = wxString_in_helper(obj1);
9469 if (arg2 == NULL) SWIG_fail;
9470 temp2 = true;
9471 }
9472 {
9473 PyThreadState* __tstate = wxPyBeginAllowThreads();
9474 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9475
9476 wxPyEndAllowThreads(__tstate);
9477 if (PyErr_Occurred()) SWIG_fail;
9478 }
9479 {
9480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9481 }
9482 {
9483 if (temp2)
9484 delete arg2;
9485 }
9486 return resultobj;
9487 fail:
9488 {
9489 if (temp2)
9490 delete arg2;
9491 }
9492 return NULL;
9493 }
9494
9495
9496 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9497 PyObject *resultobj = NULL;
9498 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9499 wxFileSystem *arg2 = 0 ;
9500 wxString *arg3 = 0 ;
9501 wxFSFile *result;
9502 bool temp3 = false ;
9503 PyObject * obj0 = 0 ;
9504 PyObject * obj1 = 0 ;
9505 PyObject * obj2 = 0 ;
9506 char *kwnames[] = {
9507 (char *) "self",(char *) "fs",(char *) "location", NULL
9508 };
9509
9510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9512 if (SWIG_arg_fail(1)) SWIG_fail;
9513 {
9514 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9515 if (SWIG_arg_fail(2)) SWIG_fail;
9516 if (arg2 == NULL) {
9517 SWIG_null_ref("wxFileSystem");
9518 }
9519 if (SWIG_arg_fail(2)) SWIG_fail;
9520 }
9521 {
9522 arg3 = wxString_in_helper(obj2);
9523 if (arg3 == NULL) SWIG_fail;
9524 temp3 = true;
9525 }
9526 {
9527 PyThreadState* __tstate = wxPyBeginAllowThreads();
9528 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9529
9530 wxPyEndAllowThreads(__tstate);
9531 if (PyErr_Occurred()) SWIG_fail;
9532 }
9533 {
9534 resultobj = wxPyMake_wxObject(result, (bool)1);
9535 }
9536 {
9537 if (temp3)
9538 delete arg3;
9539 }
9540 return resultobj;
9541 fail:
9542 {
9543 if (temp3)
9544 delete arg3;
9545 }
9546 return NULL;
9547 }
9548
9549
9550 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9551 PyObject *resultobj = NULL;
9552 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9553 wxString *arg2 = 0 ;
9554 int arg3 = (int) 0 ;
9555 wxString result;
9556 bool temp2 = false ;
9557 PyObject * obj0 = 0 ;
9558 PyObject * obj1 = 0 ;
9559 PyObject * obj2 = 0 ;
9560 char *kwnames[] = {
9561 (char *) "self",(char *) "spec",(char *) "flags", NULL
9562 };
9563
9564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9566 if (SWIG_arg_fail(1)) SWIG_fail;
9567 {
9568 arg2 = wxString_in_helper(obj1);
9569 if (arg2 == NULL) SWIG_fail;
9570 temp2 = true;
9571 }
9572 if (obj2) {
9573 {
9574 arg3 = static_cast<int >(SWIG_As_int(obj2));
9575 if (SWIG_arg_fail(3)) SWIG_fail;
9576 }
9577 }
9578 {
9579 PyThreadState* __tstate = wxPyBeginAllowThreads();
9580 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9581
9582 wxPyEndAllowThreads(__tstate);
9583 if (PyErr_Occurred()) SWIG_fail;
9584 }
9585 {
9586 #if wxUSE_UNICODE
9587 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9588 #else
9589 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9590 #endif
9591 }
9592 {
9593 if (temp2)
9594 delete arg2;
9595 }
9596 return resultobj;
9597 fail:
9598 {
9599 if (temp2)
9600 delete arg2;
9601 }
9602 return NULL;
9603 }
9604
9605
9606 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9607 PyObject *resultobj = NULL;
9608 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9609 wxString result;
9610 PyObject * obj0 = 0 ;
9611 char *kwnames[] = {
9612 (char *) "self", NULL
9613 };
9614
9615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9617 if (SWIG_arg_fail(1)) SWIG_fail;
9618 {
9619 PyThreadState* __tstate = wxPyBeginAllowThreads();
9620 result = (arg1)->FindNext();
9621
9622 wxPyEndAllowThreads(__tstate);
9623 if (PyErr_Occurred()) SWIG_fail;
9624 }
9625 {
9626 #if wxUSE_UNICODE
9627 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9628 #else
9629 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9630 #endif
9631 }
9632 return resultobj;
9633 fail:
9634 return NULL;
9635 }
9636
9637
9638 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9639 PyObject *obj;
9640 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9641 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9642 Py_INCREF(obj);
9643 return Py_BuildValue((char *)"");
9644 }
9645 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9646 PyObject *resultobj = NULL;
9647 wxString *arg1 = 0 ;
9648 wxImage *arg2 = 0 ;
9649 long arg3 ;
9650 bool temp1 = false ;
9651 PyObject * obj0 = 0 ;
9652 PyObject * obj1 = 0 ;
9653 PyObject * obj2 = 0 ;
9654 char *kwnames[] = {
9655 (char *) "filename",(char *) "image",(char *) "type", NULL
9656 };
9657
9658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9659 {
9660 arg1 = wxString_in_helper(obj0);
9661 if (arg1 == NULL) SWIG_fail;
9662 temp1 = true;
9663 }
9664 {
9665 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9666 if (SWIG_arg_fail(2)) SWIG_fail;
9667 if (arg2 == NULL) {
9668 SWIG_null_ref("wxImage");
9669 }
9670 if (SWIG_arg_fail(2)) SWIG_fail;
9671 }
9672 {
9673 arg3 = static_cast<long >(SWIG_As_long(obj2));
9674 if (SWIG_arg_fail(3)) SWIG_fail;
9675 }
9676 {
9677 PyThreadState* __tstate = wxPyBeginAllowThreads();
9678 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9679
9680 wxPyEndAllowThreads(__tstate);
9681 if (PyErr_Occurred()) SWIG_fail;
9682 }
9683 Py_INCREF(Py_None); resultobj = Py_None;
9684 {
9685 if (temp1)
9686 delete arg1;
9687 }
9688 return resultobj;
9689 fail:
9690 {
9691 if (temp1)
9692 delete arg1;
9693 }
9694 return NULL;
9695 }
9696
9697
9698 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9699 PyObject *resultobj = NULL;
9700 wxString *arg1 = 0 ;
9701 wxBitmap *arg2 = 0 ;
9702 long arg3 ;
9703 bool temp1 = false ;
9704 PyObject * obj0 = 0 ;
9705 PyObject * obj1 = 0 ;
9706 PyObject * obj2 = 0 ;
9707 char *kwnames[] = {
9708 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9709 };
9710
9711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9712 {
9713 arg1 = wxString_in_helper(obj0);
9714 if (arg1 == NULL) SWIG_fail;
9715 temp1 = true;
9716 }
9717 {
9718 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9719 if (SWIG_arg_fail(2)) SWIG_fail;
9720 if (arg2 == NULL) {
9721 SWIG_null_ref("wxBitmap");
9722 }
9723 if (SWIG_arg_fail(2)) SWIG_fail;
9724 }
9725 {
9726 arg3 = static_cast<long >(SWIG_As_long(obj2));
9727 if (SWIG_arg_fail(3)) SWIG_fail;
9728 }
9729 {
9730 PyThreadState* __tstate = wxPyBeginAllowThreads();
9731 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9732
9733 wxPyEndAllowThreads(__tstate);
9734 if (PyErr_Occurred()) SWIG_fail;
9735 }
9736 Py_INCREF(Py_None); resultobj = Py_None;
9737 {
9738 if (temp1)
9739 delete arg1;
9740 }
9741 return resultobj;
9742 fail:
9743 {
9744 if (temp1)
9745 delete arg1;
9746 }
9747 return NULL;
9748 }
9749
9750
9751 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9752 PyObject *resultobj = NULL;
9753 wxString *arg1 = 0 ;
9754 PyObject *arg2 = (PyObject *) 0 ;
9755 bool temp1 = false ;
9756 PyObject * obj0 = 0 ;
9757 PyObject * obj1 = 0 ;
9758 char *kwnames[] = {
9759 (char *) "filename",(char *) "data", NULL
9760 };
9761
9762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9763 {
9764 arg1 = wxString_in_helper(obj0);
9765 if (arg1 == NULL) SWIG_fail;
9766 temp1 = true;
9767 }
9768 arg2 = obj1;
9769 {
9770 PyThreadState* __tstate = wxPyBeginAllowThreads();
9771 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9772
9773 wxPyEndAllowThreads(__tstate);
9774 if (PyErr_Occurred()) SWIG_fail;
9775 }
9776 Py_INCREF(Py_None); resultobj = Py_None;
9777 {
9778 if (temp1)
9779 delete arg1;
9780 }
9781 return resultobj;
9782 fail:
9783 {
9784 if (temp1)
9785 delete arg1;
9786 }
9787 return NULL;
9788 }
9789
9790
9791 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9792 PyObject *resultobj = NULL;
9793 wxMemoryFSHandler *result;
9794 char *kwnames[] = {
9795 NULL
9796 };
9797
9798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9799 {
9800 PyThreadState* __tstate = wxPyBeginAllowThreads();
9801 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9802
9803 wxPyEndAllowThreads(__tstate);
9804 if (PyErr_Occurred()) SWIG_fail;
9805 }
9806 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9807 return resultobj;
9808 fail:
9809 return NULL;
9810 }
9811
9812
9813 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9814 PyObject *resultobj = NULL;
9815 wxString *arg1 = 0 ;
9816 bool temp1 = false ;
9817 PyObject * obj0 = 0 ;
9818 char *kwnames[] = {
9819 (char *) "filename", NULL
9820 };
9821
9822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9823 {
9824 arg1 = wxString_in_helper(obj0);
9825 if (arg1 == NULL) SWIG_fail;
9826 temp1 = true;
9827 }
9828 {
9829 PyThreadState* __tstate = wxPyBeginAllowThreads();
9830 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9831
9832 wxPyEndAllowThreads(__tstate);
9833 if (PyErr_Occurred()) SWIG_fail;
9834 }
9835 Py_INCREF(Py_None); resultobj = Py_None;
9836 {
9837 if (temp1)
9838 delete arg1;
9839 }
9840 return resultobj;
9841 fail:
9842 {
9843 if (temp1)
9844 delete arg1;
9845 }
9846 return NULL;
9847 }
9848
9849
9850 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9851 PyObject *resultobj = NULL;
9852 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9853 wxString *arg2 = 0 ;
9854 bool result;
9855 bool temp2 = false ;
9856 PyObject * obj0 = 0 ;
9857 PyObject * obj1 = 0 ;
9858 char *kwnames[] = {
9859 (char *) "self",(char *) "location", NULL
9860 };
9861
9862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9864 if (SWIG_arg_fail(1)) SWIG_fail;
9865 {
9866 arg2 = wxString_in_helper(obj1);
9867 if (arg2 == NULL) SWIG_fail;
9868 temp2 = true;
9869 }
9870 {
9871 PyThreadState* __tstate = wxPyBeginAllowThreads();
9872 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9873
9874 wxPyEndAllowThreads(__tstate);
9875 if (PyErr_Occurred()) SWIG_fail;
9876 }
9877 {
9878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9879 }
9880 {
9881 if (temp2)
9882 delete arg2;
9883 }
9884 return resultobj;
9885 fail:
9886 {
9887 if (temp2)
9888 delete arg2;
9889 }
9890 return NULL;
9891 }
9892
9893
9894 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9895 PyObject *resultobj = NULL;
9896 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9897 wxFileSystem *arg2 = 0 ;
9898 wxString *arg3 = 0 ;
9899 wxFSFile *result;
9900 bool temp3 = false ;
9901 PyObject * obj0 = 0 ;
9902 PyObject * obj1 = 0 ;
9903 PyObject * obj2 = 0 ;
9904 char *kwnames[] = {
9905 (char *) "self",(char *) "fs",(char *) "location", NULL
9906 };
9907
9908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9910 if (SWIG_arg_fail(1)) SWIG_fail;
9911 {
9912 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9913 if (SWIG_arg_fail(2)) SWIG_fail;
9914 if (arg2 == NULL) {
9915 SWIG_null_ref("wxFileSystem");
9916 }
9917 if (SWIG_arg_fail(2)) SWIG_fail;
9918 }
9919 {
9920 arg3 = wxString_in_helper(obj2);
9921 if (arg3 == NULL) SWIG_fail;
9922 temp3 = true;
9923 }
9924 {
9925 PyThreadState* __tstate = wxPyBeginAllowThreads();
9926 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9927
9928 wxPyEndAllowThreads(__tstate);
9929 if (PyErr_Occurred()) SWIG_fail;
9930 }
9931 {
9932 resultobj = wxPyMake_wxObject(result, (bool)1);
9933 }
9934 {
9935 if (temp3)
9936 delete arg3;
9937 }
9938 return resultobj;
9939 fail:
9940 {
9941 if (temp3)
9942 delete arg3;
9943 }
9944 return NULL;
9945 }
9946
9947
9948 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9949 PyObject *resultobj = NULL;
9950 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9951 wxString *arg2 = 0 ;
9952 int arg3 = (int) 0 ;
9953 wxString result;
9954 bool temp2 = false ;
9955 PyObject * obj0 = 0 ;
9956 PyObject * obj1 = 0 ;
9957 PyObject * obj2 = 0 ;
9958 char *kwnames[] = {
9959 (char *) "self",(char *) "spec",(char *) "flags", NULL
9960 };
9961
9962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9964 if (SWIG_arg_fail(1)) SWIG_fail;
9965 {
9966 arg2 = wxString_in_helper(obj1);
9967 if (arg2 == NULL) SWIG_fail;
9968 temp2 = true;
9969 }
9970 if (obj2) {
9971 {
9972 arg3 = static_cast<int >(SWIG_As_int(obj2));
9973 if (SWIG_arg_fail(3)) SWIG_fail;
9974 }
9975 }
9976 {
9977 PyThreadState* __tstate = wxPyBeginAllowThreads();
9978 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9979
9980 wxPyEndAllowThreads(__tstate);
9981 if (PyErr_Occurred()) SWIG_fail;
9982 }
9983 {
9984 #if wxUSE_UNICODE
9985 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9986 #else
9987 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9988 #endif
9989 }
9990 {
9991 if (temp2)
9992 delete arg2;
9993 }
9994 return resultobj;
9995 fail:
9996 {
9997 if (temp2)
9998 delete arg2;
9999 }
10000 return NULL;
10001 }
10002
10003
10004 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
10005 PyObject *resultobj = NULL;
10006 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
10007 wxString result;
10008 PyObject * obj0 = 0 ;
10009 char *kwnames[] = {
10010 (char *) "self", NULL
10011 };
10012
10013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
10014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
10015 if (SWIG_arg_fail(1)) SWIG_fail;
10016 {
10017 PyThreadState* __tstate = wxPyBeginAllowThreads();
10018 result = (arg1)->FindNext();
10019
10020 wxPyEndAllowThreads(__tstate);
10021 if (PyErr_Occurred()) SWIG_fail;
10022 }
10023 {
10024 #if wxUSE_UNICODE
10025 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10026 #else
10027 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10028 #endif
10029 }
10030 return resultobj;
10031 fail:
10032 return NULL;
10033 }
10034
10035
10036 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
10037 PyObject *obj;
10038 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10039 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
10040 Py_INCREF(obj);
10041 return Py_BuildValue((char *)"");
10042 }
10043 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
10044 PyObject *resultobj = NULL;
10045 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10046 wxString result;
10047 PyObject * obj0 = 0 ;
10048 char *kwnames[] = {
10049 (char *) "self", NULL
10050 };
10051
10052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
10053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10054 if (SWIG_arg_fail(1)) SWIG_fail;
10055 {
10056 PyThreadState* __tstate = wxPyBeginAllowThreads();
10057 result = (arg1)->GetName();
10058
10059 wxPyEndAllowThreads(__tstate);
10060 if (PyErr_Occurred()) SWIG_fail;
10061 }
10062 {
10063 #if wxUSE_UNICODE
10064 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10065 #else
10066 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10067 #endif
10068 }
10069 return resultobj;
10070 fail:
10071 return NULL;
10072 }
10073
10074
10075 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10076 PyObject *resultobj = NULL;
10077 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10078 wxString result;
10079 PyObject * obj0 = 0 ;
10080 char *kwnames[] = {
10081 (char *) "self", NULL
10082 };
10083
10084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
10085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10086 if (SWIG_arg_fail(1)) SWIG_fail;
10087 {
10088 PyThreadState* __tstate = wxPyBeginAllowThreads();
10089 result = (arg1)->GetExtension();
10090
10091 wxPyEndAllowThreads(__tstate);
10092 if (PyErr_Occurred()) SWIG_fail;
10093 }
10094 {
10095 #if wxUSE_UNICODE
10096 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10097 #else
10098 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10099 #endif
10100 }
10101 return resultobj;
10102 fail:
10103 return NULL;
10104 }
10105
10106
10107 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
10108 PyObject *resultobj = NULL;
10109 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10110 long result;
10111 PyObject * obj0 = 0 ;
10112 char *kwnames[] = {
10113 (char *) "self", NULL
10114 };
10115
10116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
10117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10118 if (SWIG_arg_fail(1)) SWIG_fail;
10119 {
10120 PyThreadState* __tstate = wxPyBeginAllowThreads();
10121 result = (long)(arg1)->GetType();
10122
10123 wxPyEndAllowThreads(__tstate);
10124 if (PyErr_Occurred()) SWIG_fail;
10125 }
10126 {
10127 resultobj = SWIG_From_long(static_cast<long >(result));
10128 }
10129 return resultobj;
10130 fail:
10131 return NULL;
10132 }
10133
10134
10135 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10136 PyObject *resultobj = NULL;
10137 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10138 wxString result;
10139 PyObject * obj0 = 0 ;
10140 char *kwnames[] = {
10141 (char *) "self", NULL
10142 };
10143
10144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
10145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10146 if (SWIG_arg_fail(1)) SWIG_fail;
10147 {
10148 PyThreadState* __tstate = wxPyBeginAllowThreads();
10149 result = (arg1)->GetMimeType();
10150
10151 wxPyEndAllowThreads(__tstate);
10152 if (PyErr_Occurred()) SWIG_fail;
10153 }
10154 {
10155 #if wxUSE_UNICODE
10156 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10157 #else
10158 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10159 #endif
10160 }
10161 return resultobj;
10162 fail:
10163 return NULL;
10164 }
10165
10166
10167 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10168 PyObject *resultobj = NULL;
10169 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10170 wxString *arg2 = 0 ;
10171 bool result;
10172 bool temp2 = false ;
10173 PyObject * obj0 = 0 ;
10174 PyObject * obj1 = 0 ;
10175 char *kwnames[] = {
10176 (char *) "self",(char *) "name", NULL
10177 };
10178
10179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10181 if (SWIG_arg_fail(1)) SWIG_fail;
10182 {
10183 arg2 = wxString_in_helper(obj1);
10184 if (arg2 == NULL) SWIG_fail;
10185 temp2 = true;
10186 }
10187 {
10188 PyThreadState* __tstate = wxPyBeginAllowThreads();
10189 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10190
10191 wxPyEndAllowThreads(__tstate);
10192 if (PyErr_Occurred()) SWIG_fail;
10193 }
10194 {
10195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10196 }
10197 {
10198 if (temp2)
10199 delete arg2;
10200 }
10201 return resultobj;
10202 fail:
10203 {
10204 if (temp2)
10205 delete arg2;
10206 }
10207 return NULL;
10208 }
10209
10210
10211 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10212 PyObject *resultobj = NULL;
10213 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10214 wxString *arg2 = 0 ;
10215 bool temp2 = false ;
10216 PyObject * obj0 = 0 ;
10217 PyObject * obj1 = 0 ;
10218 char *kwnames[] = {
10219 (char *) "self",(char *) "name", NULL
10220 };
10221
10222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10224 if (SWIG_arg_fail(1)) SWIG_fail;
10225 {
10226 arg2 = wxString_in_helper(obj1);
10227 if (arg2 == NULL) SWIG_fail;
10228 temp2 = true;
10229 }
10230 {
10231 PyThreadState* __tstate = wxPyBeginAllowThreads();
10232 (arg1)->SetName((wxString const &)*arg2);
10233
10234 wxPyEndAllowThreads(__tstate);
10235 if (PyErr_Occurred()) SWIG_fail;
10236 }
10237 Py_INCREF(Py_None); resultobj = Py_None;
10238 {
10239 if (temp2)
10240 delete arg2;
10241 }
10242 return resultobj;
10243 fail:
10244 {
10245 if (temp2)
10246 delete arg2;
10247 }
10248 return NULL;
10249 }
10250
10251
10252 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10253 PyObject *resultobj = NULL;
10254 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10255 wxString *arg2 = 0 ;
10256 bool temp2 = false ;
10257 PyObject * obj0 = 0 ;
10258 PyObject * obj1 = 0 ;
10259 char *kwnames[] = {
10260 (char *) "self",(char *) "extension", NULL
10261 };
10262
10263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10265 if (SWIG_arg_fail(1)) SWIG_fail;
10266 {
10267 arg2 = wxString_in_helper(obj1);
10268 if (arg2 == NULL) SWIG_fail;
10269 temp2 = true;
10270 }
10271 {
10272 PyThreadState* __tstate = wxPyBeginAllowThreads();
10273 (arg1)->SetExtension((wxString const &)*arg2);
10274
10275 wxPyEndAllowThreads(__tstate);
10276 if (PyErr_Occurred()) SWIG_fail;
10277 }
10278 Py_INCREF(Py_None); resultobj = Py_None;
10279 {
10280 if (temp2)
10281 delete arg2;
10282 }
10283 return resultobj;
10284 fail:
10285 {
10286 if (temp2)
10287 delete arg2;
10288 }
10289 return NULL;
10290 }
10291
10292
10293 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10294 PyObject *resultobj = NULL;
10295 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10296 long arg2 ;
10297 PyObject * obj0 = 0 ;
10298 PyObject * obj1 = 0 ;
10299 char *kwnames[] = {
10300 (char *) "self",(char *) "type", NULL
10301 };
10302
10303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10305 if (SWIG_arg_fail(1)) SWIG_fail;
10306 {
10307 arg2 = static_cast<long >(SWIG_As_long(obj1));
10308 if (SWIG_arg_fail(2)) SWIG_fail;
10309 }
10310 {
10311 PyThreadState* __tstate = wxPyBeginAllowThreads();
10312 (arg1)->SetType(arg2);
10313
10314 wxPyEndAllowThreads(__tstate);
10315 if (PyErr_Occurred()) SWIG_fail;
10316 }
10317 Py_INCREF(Py_None); resultobj = Py_None;
10318 return resultobj;
10319 fail:
10320 return NULL;
10321 }
10322
10323
10324 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10325 PyObject *resultobj = NULL;
10326 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10327 wxString *arg2 = 0 ;
10328 bool temp2 = false ;
10329 PyObject * obj0 = 0 ;
10330 PyObject * obj1 = 0 ;
10331 char *kwnames[] = {
10332 (char *) "self",(char *) "mimetype", NULL
10333 };
10334
10335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10337 if (SWIG_arg_fail(1)) SWIG_fail;
10338 {
10339 arg2 = wxString_in_helper(obj1);
10340 if (arg2 == NULL) SWIG_fail;
10341 temp2 = true;
10342 }
10343 {
10344 PyThreadState* __tstate = wxPyBeginAllowThreads();
10345 (arg1)->SetMimeType((wxString const &)*arg2);
10346
10347 wxPyEndAllowThreads(__tstate);
10348 if (PyErr_Occurred()) SWIG_fail;
10349 }
10350 Py_INCREF(Py_None); resultobj = Py_None;
10351 {
10352 if (temp2)
10353 delete arg2;
10354 }
10355 return resultobj;
10356 fail:
10357 {
10358 if (temp2)
10359 delete arg2;
10360 }
10361 return NULL;
10362 }
10363
10364
10365 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10366 PyObject *obj;
10367 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10368 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10369 Py_INCREF(obj);
10370 return Py_BuildValue((char *)"");
10371 }
10372 static PyObject *_wrap_new_PyImageHandler(PyObject *, PyObject *args, PyObject *kwargs) {
10373 PyObject *resultobj = NULL;
10374 wxPyImageHandler *result;
10375 char *kwnames[] = {
10376 NULL
10377 };
10378
10379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyImageHandler",kwnames)) goto fail;
10380 {
10381 PyThreadState* __tstate = wxPyBeginAllowThreads();
10382 result = (wxPyImageHandler *)new wxPyImageHandler();
10383
10384 wxPyEndAllowThreads(__tstate);
10385 if (PyErr_Occurred()) SWIG_fail;
10386 }
10387 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyImageHandler, 1);
10388 return resultobj;
10389 fail:
10390 return NULL;
10391 }
10392
10393
10394 static PyObject *_wrap_PyImageHandler__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
10395 PyObject *resultobj = NULL;
10396 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
10397 PyObject *arg2 = (PyObject *) 0 ;
10398 PyObject * obj0 = 0 ;
10399 PyObject * obj1 = 0 ;
10400 char *kwnames[] = {
10401 (char *) "self",(char *) "self", NULL
10402 };
10403
10404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) goto fail;
10405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_EXCEPTION | 0);
10406 if (SWIG_arg_fail(1)) SWIG_fail;
10407 arg2 = obj1;
10408 {
10409 PyThreadState* __tstate = wxPyBeginAllowThreads();
10410 (arg1)->_SetSelf(arg2);
10411
10412 wxPyEndAllowThreads(__tstate);
10413 if (PyErr_Occurred()) SWIG_fail;
10414 }
10415 Py_INCREF(Py_None); resultobj = Py_None;
10416 return resultobj;
10417 fail:
10418 return NULL;
10419 }
10420
10421
10422 static PyObject * PyImageHandler_swigregister(PyObject *, PyObject *args) {
10423 PyObject *obj;
10424 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10425 SWIG_TypeClientData(SWIGTYPE_p_wxPyImageHandler, obj);
10426 Py_INCREF(obj);
10427 return Py_BuildValue((char *)"");
10428 }
10429 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10430 PyObject *resultobj = NULL;
10431 wxImageHistogram *result;
10432 char *kwnames[] = {
10433 NULL
10434 };
10435
10436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10437 {
10438 PyThreadState* __tstate = wxPyBeginAllowThreads();
10439 result = (wxImageHistogram *)new wxImageHistogram();
10440
10441 wxPyEndAllowThreads(__tstate);
10442 if (PyErr_Occurred()) SWIG_fail;
10443 }
10444 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10445 return resultobj;
10446 fail:
10447 return NULL;
10448 }
10449
10450
10451 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10452 PyObject *resultobj = NULL;
10453 byte arg1 ;
10454 byte arg2 ;
10455 byte arg3 ;
10456 unsigned long result;
10457 PyObject * obj0 = 0 ;
10458 PyObject * obj1 = 0 ;
10459 PyObject * obj2 = 0 ;
10460 char *kwnames[] = {
10461 (char *) "r",(char *) "g",(char *) "b", NULL
10462 };
10463
10464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10465 {
10466 arg1 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj0));
10467 if (SWIG_arg_fail(1)) SWIG_fail;
10468 }
10469 {
10470 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10471 if (SWIG_arg_fail(2)) SWIG_fail;
10472 }
10473 {
10474 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10475 if (SWIG_arg_fail(3)) SWIG_fail;
10476 }
10477 {
10478 PyThreadState* __tstate = wxPyBeginAllowThreads();
10479 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10480
10481 wxPyEndAllowThreads(__tstate);
10482 if (PyErr_Occurred()) SWIG_fail;
10483 }
10484 {
10485 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10486 }
10487 return resultobj;
10488 fail:
10489 return NULL;
10490 }
10491
10492
10493 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10494 PyObject *resultobj = NULL;
10495 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10496 byte *arg2 = (byte *) 0 ;
10497 byte *arg3 = (byte *) 0 ;
10498 byte *arg4 = (byte *) 0 ;
10499 byte arg5 = (byte) 1 ;
10500 byte arg6 = (byte) 0 ;
10501 byte arg7 = (byte) 0 ;
10502 bool result;
10503 byte temp2 ;
10504 int res2 = 0 ;
10505 byte temp3 ;
10506 int res3 = 0 ;
10507 byte temp4 ;
10508 int res4 = 0 ;
10509 PyObject * obj0 = 0 ;
10510 PyObject * obj1 = 0 ;
10511 PyObject * obj2 = 0 ;
10512 PyObject * obj3 = 0 ;
10513 char *kwnames[] = {
10514 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10515 };
10516
10517 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10518 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10519 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10522 if (SWIG_arg_fail(1)) SWIG_fail;
10523 if (obj1) {
10524 {
10525 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10526 if (SWIG_arg_fail(5)) SWIG_fail;
10527 }
10528 }
10529 if (obj2) {
10530 {
10531 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10532 if (SWIG_arg_fail(6)) SWIG_fail;
10533 }
10534 }
10535 if (obj3) {
10536 {
10537 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
10538 if (SWIG_arg_fail(7)) SWIG_fail;
10539 }
10540 }
10541 {
10542 PyThreadState* __tstate = wxPyBeginAllowThreads();
10543 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10544
10545 wxPyEndAllowThreads(__tstate);
10546 if (PyErr_Occurred()) SWIG_fail;
10547 }
10548 {
10549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10550 }
10551 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10552 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10553 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10554 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10555 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10556 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10557 return resultobj;
10558 fail:
10559 return NULL;
10560 }
10561
10562
10563 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10564 PyObject *resultobj = NULL;
10565 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10566 unsigned long arg2 ;
10567 unsigned long result;
10568 PyObject * obj0 = 0 ;
10569 PyObject * obj1 = 0 ;
10570 char *kwnames[] = {
10571 (char *) "self",(char *) "key", NULL
10572 };
10573
10574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10576 if (SWIG_arg_fail(1)) SWIG_fail;
10577 {
10578 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
10579 if (SWIG_arg_fail(2)) SWIG_fail;
10580 }
10581 {
10582 PyThreadState* __tstate = wxPyBeginAllowThreads();
10583 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10584
10585 wxPyEndAllowThreads(__tstate);
10586 if (PyErr_Occurred()) SWIG_fail;
10587 }
10588 {
10589 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10590 }
10591 return resultobj;
10592 fail:
10593 return NULL;
10594 }
10595
10596
10597 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10598 PyObject *resultobj = NULL;
10599 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10600 byte arg2 ;
10601 byte arg3 ;
10602 byte arg4 ;
10603 unsigned long result;
10604 PyObject * obj0 = 0 ;
10605 PyObject * obj1 = 0 ;
10606 PyObject * obj2 = 0 ;
10607 PyObject * obj3 = 0 ;
10608 char *kwnames[] = {
10609 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10610 };
10611
10612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10614 if (SWIG_arg_fail(1)) SWIG_fail;
10615 {
10616 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10617 if (SWIG_arg_fail(2)) SWIG_fail;
10618 }
10619 {
10620 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10621 if (SWIG_arg_fail(3)) SWIG_fail;
10622 }
10623 {
10624 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
10625 if (SWIG_arg_fail(4)) SWIG_fail;
10626 }
10627 {
10628 PyThreadState* __tstate = wxPyBeginAllowThreads();
10629 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10630
10631 wxPyEndAllowThreads(__tstate);
10632 if (PyErr_Occurred()) SWIG_fail;
10633 }
10634 {
10635 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10636 }
10637 return resultobj;
10638 fail:
10639 return NULL;
10640 }
10641
10642
10643 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10644 PyObject *resultobj = NULL;
10645 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10646 wxColour *arg2 = 0 ;
10647 unsigned long result;
10648 wxColour temp2 ;
10649 PyObject * obj0 = 0 ;
10650 PyObject * obj1 = 0 ;
10651 char *kwnames[] = {
10652 (char *) "self",(char *) "colour", NULL
10653 };
10654
10655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10657 if (SWIG_arg_fail(1)) SWIG_fail;
10658 {
10659 arg2 = &temp2;
10660 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10661 }
10662 {
10663 PyThreadState* __tstate = wxPyBeginAllowThreads();
10664 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10665
10666 wxPyEndAllowThreads(__tstate);
10667 if (PyErr_Occurred()) SWIG_fail;
10668 }
10669 {
10670 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10671 }
10672 return resultobj;
10673 fail:
10674 return NULL;
10675 }
10676
10677
10678 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10679 PyObject *obj;
10680 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10681 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10682 Py_INCREF(obj);
10683 return Py_BuildValue((char *)"");
10684 }
10685 static PyObject *_wrap_new_Image_RGBValue(PyObject *, PyObject *args, PyObject *kwargs) {
10686 PyObject *resultobj = NULL;
10687 byte arg1 = (byte) 0 ;
10688 byte arg2 = (byte) 0 ;
10689 byte arg3 = (byte) 0 ;
10690 wxImage_RGBValue *result;
10691 PyObject * obj0 = 0 ;
10692 PyObject * obj1 = 0 ;
10693 PyObject * obj2 = 0 ;
10694 char *kwnames[] = {
10695 (char *) "r",(char *) "g",(char *) "b", NULL
10696 };
10697
10698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10699 if (obj0) {
10700 {
10701 arg1 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj0));
10702 if (SWIG_arg_fail(1)) SWIG_fail;
10703 }
10704 }
10705 if (obj1) {
10706 {
10707 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10708 if (SWIG_arg_fail(2)) SWIG_fail;
10709 }
10710 }
10711 if (obj2) {
10712 {
10713 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10714 if (SWIG_arg_fail(3)) SWIG_fail;
10715 }
10716 }
10717 {
10718 PyThreadState* __tstate = wxPyBeginAllowThreads();
10719 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
10720
10721 wxPyEndAllowThreads(__tstate);
10722 if (PyErr_Occurred()) SWIG_fail;
10723 }
10724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_RGBValue, 1);
10725 return resultobj;
10726 fail:
10727 return NULL;
10728 }
10729
10730
10731 static PyObject *_wrap_Image_RGBValue_red_set(PyObject *, PyObject *args, PyObject *kwargs) {
10732 PyObject *resultobj = NULL;
10733 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10734 byte arg2 ;
10735 PyObject * obj0 = 0 ;
10736 PyObject * obj1 = 0 ;
10737 char *kwnames[] = {
10738 (char *) "self",(char *) "red", NULL
10739 };
10740
10741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_red_set",kwnames,&obj0,&obj1)) goto fail;
10742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10743 if (SWIG_arg_fail(1)) SWIG_fail;
10744 {
10745 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10746 if (SWIG_arg_fail(2)) SWIG_fail;
10747 }
10748 if (arg1) (arg1)->red = arg2;
10749
10750 Py_INCREF(Py_None); resultobj = Py_None;
10751 return resultobj;
10752 fail:
10753 return NULL;
10754 }
10755
10756
10757 static PyObject *_wrap_Image_RGBValue_red_get(PyObject *, PyObject *args, PyObject *kwargs) {
10758 PyObject *resultobj = NULL;
10759 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10760 byte result;
10761 PyObject * obj0 = 0 ;
10762 char *kwnames[] = {
10763 (char *) "self", NULL
10764 };
10765
10766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_red_get",kwnames,&obj0)) goto fail;
10767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10768 if (SWIG_arg_fail(1)) SWIG_fail;
10769 result = (byte) ((arg1)->red);
10770
10771 {
10772 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10773 }
10774 return resultobj;
10775 fail:
10776 return NULL;
10777 }
10778
10779
10780 static PyObject *_wrap_Image_RGBValue_green_set(PyObject *, PyObject *args, PyObject *kwargs) {
10781 PyObject *resultobj = NULL;
10782 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10783 byte arg2 ;
10784 PyObject * obj0 = 0 ;
10785 PyObject * obj1 = 0 ;
10786 char *kwnames[] = {
10787 (char *) "self",(char *) "green", NULL
10788 };
10789
10790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_green_set",kwnames,&obj0,&obj1)) goto fail;
10791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10792 if (SWIG_arg_fail(1)) SWIG_fail;
10793 {
10794 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10795 if (SWIG_arg_fail(2)) SWIG_fail;
10796 }
10797 if (arg1) (arg1)->green = arg2;
10798
10799 Py_INCREF(Py_None); resultobj = Py_None;
10800 return resultobj;
10801 fail:
10802 return NULL;
10803 }
10804
10805
10806 static PyObject *_wrap_Image_RGBValue_green_get(PyObject *, PyObject *args, PyObject *kwargs) {
10807 PyObject *resultobj = NULL;
10808 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10809 byte result;
10810 PyObject * obj0 = 0 ;
10811 char *kwnames[] = {
10812 (char *) "self", NULL
10813 };
10814
10815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_green_get",kwnames,&obj0)) goto fail;
10816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10817 if (SWIG_arg_fail(1)) SWIG_fail;
10818 result = (byte) ((arg1)->green);
10819
10820 {
10821 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10822 }
10823 return resultobj;
10824 fail:
10825 return NULL;
10826 }
10827
10828
10829 static PyObject *_wrap_Image_RGBValue_blue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10830 PyObject *resultobj = NULL;
10831 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10832 byte arg2 ;
10833 PyObject * obj0 = 0 ;
10834 PyObject * obj1 = 0 ;
10835 char *kwnames[] = {
10836 (char *) "self",(char *) "blue", NULL
10837 };
10838
10839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_blue_set",kwnames,&obj0,&obj1)) goto fail;
10840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10841 if (SWIG_arg_fail(1)) SWIG_fail;
10842 {
10843 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10844 if (SWIG_arg_fail(2)) SWIG_fail;
10845 }
10846 if (arg1) (arg1)->blue = arg2;
10847
10848 Py_INCREF(Py_None); resultobj = Py_None;
10849 return resultobj;
10850 fail:
10851 return NULL;
10852 }
10853
10854
10855 static PyObject *_wrap_Image_RGBValue_blue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10856 PyObject *resultobj = NULL;
10857 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10858 byte result;
10859 PyObject * obj0 = 0 ;
10860 char *kwnames[] = {
10861 (char *) "self", NULL
10862 };
10863
10864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_blue_get",kwnames,&obj0)) goto fail;
10865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10866 if (SWIG_arg_fail(1)) SWIG_fail;
10867 result = (byte) ((arg1)->blue);
10868
10869 {
10870 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10871 }
10872 return resultobj;
10873 fail:
10874 return NULL;
10875 }
10876
10877
10878 static PyObject * Image_RGBValue_swigregister(PyObject *, PyObject *args) {
10879 PyObject *obj;
10880 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10881 SWIG_TypeClientData(SWIGTYPE_p_wxImage_RGBValue, obj);
10882 Py_INCREF(obj);
10883 return Py_BuildValue((char *)"");
10884 }
10885 static PyObject *_wrap_new_Image_HSVValue(PyObject *, PyObject *args, PyObject *kwargs) {
10886 PyObject *resultobj = NULL;
10887 double arg1 = (double) 0.0 ;
10888 double arg2 = (double) 0.0 ;
10889 double arg3 = (double) 0.0 ;
10890 wxImage_HSVValue *result;
10891 PyObject * obj0 = 0 ;
10892 PyObject * obj1 = 0 ;
10893 PyObject * obj2 = 0 ;
10894 char *kwnames[] = {
10895 (char *) "h",(char *) "s",(char *) "v", NULL
10896 };
10897
10898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10899 if (obj0) {
10900 {
10901 arg1 = static_cast<double >(SWIG_As_double(obj0));
10902 if (SWIG_arg_fail(1)) SWIG_fail;
10903 }
10904 }
10905 if (obj1) {
10906 {
10907 arg2 = static_cast<double >(SWIG_As_double(obj1));
10908 if (SWIG_arg_fail(2)) SWIG_fail;
10909 }
10910 }
10911 if (obj2) {
10912 {
10913 arg3 = static_cast<double >(SWIG_As_double(obj2));
10914 if (SWIG_arg_fail(3)) SWIG_fail;
10915 }
10916 }
10917 {
10918 PyThreadState* __tstate = wxPyBeginAllowThreads();
10919 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
10920
10921 wxPyEndAllowThreads(__tstate);
10922 if (PyErr_Occurred()) SWIG_fail;
10923 }
10924 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_HSVValue, 1);
10925 return resultobj;
10926 fail:
10927 return NULL;
10928 }
10929
10930
10931 static PyObject *_wrap_Image_HSVValue_hue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10932 PyObject *resultobj = NULL;
10933 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10934 double arg2 ;
10935 PyObject * obj0 = 0 ;
10936 PyObject * obj1 = 0 ;
10937 char *kwnames[] = {
10938 (char *) "self",(char *) "hue", NULL
10939 };
10940
10941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_hue_set",kwnames,&obj0,&obj1)) goto fail;
10942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10943 if (SWIG_arg_fail(1)) SWIG_fail;
10944 {
10945 arg2 = static_cast<double >(SWIG_As_double(obj1));
10946 if (SWIG_arg_fail(2)) SWIG_fail;
10947 }
10948 if (arg1) (arg1)->hue = arg2;
10949
10950 Py_INCREF(Py_None); resultobj = Py_None;
10951 return resultobj;
10952 fail:
10953 return NULL;
10954 }
10955
10956
10957 static PyObject *_wrap_Image_HSVValue_hue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10958 PyObject *resultobj = NULL;
10959 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10960 double result;
10961 PyObject * obj0 = 0 ;
10962 char *kwnames[] = {
10963 (char *) "self", NULL
10964 };
10965
10966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_hue_get",kwnames,&obj0)) goto fail;
10967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10968 if (SWIG_arg_fail(1)) SWIG_fail;
10969 result = (double) ((arg1)->hue);
10970
10971 {
10972 resultobj = SWIG_From_double(static_cast<double >(result));
10973 }
10974 return resultobj;
10975 fail:
10976 return NULL;
10977 }
10978
10979
10980 static PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *, PyObject *args, PyObject *kwargs) {
10981 PyObject *resultobj = NULL;
10982 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10983 double arg2 ;
10984 PyObject * obj0 = 0 ;
10985 PyObject * obj1 = 0 ;
10986 char *kwnames[] = {
10987 (char *) "self",(char *) "saturation", NULL
10988 };
10989
10990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_saturation_set",kwnames,&obj0,&obj1)) goto fail;
10991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10992 if (SWIG_arg_fail(1)) SWIG_fail;
10993 {
10994 arg2 = static_cast<double >(SWIG_As_double(obj1));
10995 if (SWIG_arg_fail(2)) SWIG_fail;
10996 }
10997 if (arg1) (arg1)->saturation = arg2;
10998
10999 Py_INCREF(Py_None); resultobj = Py_None;
11000 return resultobj;
11001 fail:
11002 return NULL;
11003 }
11004
11005
11006 static PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *, PyObject *args, PyObject *kwargs) {
11007 PyObject *resultobj = NULL;
11008 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11009 double result;
11010 PyObject * obj0 = 0 ;
11011 char *kwnames[] = {
11012 (char *) "self", NULL
11013 };
11014
11015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_saturation_get",kwnames,&obj0)) goto fail;
11016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11017 if (SWIG_arg_fail(1)) SWIG_fail;
11018 result = (double) ((arg1)->saturation);
11019
11020 {
11021 resultobj = SWIG_From_double(static_cast<double >(result));
11022 }
11023 return resultobj;
11024 fail:
11025 return NULL;
11026 }
11027
11028
11029 static PyObject *_wrap_Image_HSVValue_value_set(PyObject *, PyObject *args, PyObject *kwargs) {
11030 PyObject *resultobj = NULL;
11031 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11032 double arg2 ;
11033 PyObject * obj0 = 0 ;
11034 PyObject * obj1 = 0 ;
11035 char *kwnames[] = {
11036 (char *) "self",(char *) "value", NULL
11037 };
11038
11039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_value_set",kwnames,&obj0,&obj1)) goto fail;
11040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11041 if (SWIG_arg_fail(1)) SWIG_fail;
11042 {
11043 arg2 = static_cast<double >(SWIG_As_double(obj1));
11044 if (SWIG_arg_fail(2)) SWIG_fail;
11045 }
11046 if (arg1) (arg1)->value = arg2;
11047
11048 Py_INCREF(Py_None); resultobj = Py_None;
11049 return resultobj;
11050 fail:
11051 return NULL;
11052 }
11053
11054
11055 static PyObject *_wrap_Image_HSVValue_value_get(PyObject *, PyObject *args, PyObject *kwargs) {
11056 PyObject *resultobj = NULL;
11057 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11058 double result;
11059 PyObject * obj0 = 0 ;
11060 char *kwnames[] = {
11061 (char *) "self", NULL
11062 };
11063
11064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_value_get",kwnames,&obj0)) goto fail;
11065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11066 if (SWIG_arg_fail(1)) SWIG_fail;
11067 result = (double) ((arg1)->value);
11068
11069 {
11070 resultobj = SWIG_From_double(static_cast<double >(result));
11071 }
11072 return resultobj;
11073 fail:
11074 return NULL;
11075 }
11076
11077
11078 static PyObject * Image_HSVValue_swigregister(PyObject *, PyObject *args) {
11079 PyObject *obj;
11080 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11081 SWIG_TypeClientData(SWIGTYPE_p_wxImage_HSVValue, obj);
11082 Py_INCREF(obj);
11083 return Py_BuildValue((char *)"");
11084 }
11085 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11086 PyObject *resultobj = NULL;
11087 wxString *arg1 = 0 ;
11088 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11089 int arg3 = (int) -1 ;
11090 wxImage *result;
11091 bool temp1 = false ;
11092 PyObject * obj0 = 0 ;
11093 PyObject * obj1 = 0 ;
11094 PyObject * obj2 = 0 ;
11095 char *kwnames[] = {
11096 (char *) "name",(char *) "type",(char *) "index", NULL
11097 };
11098
11099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
11100 {
11101 arg1 = wxString_in_helper(obj0);
11102 if (arg1 == NULL) SWIG_fail;
11103 temp1 = true;
11104 }
11105 if (obj1) {
11106 {
11107 arg2 = static_cast<long >(SWIG_As_long(obj1));
11108 if (SWIG_arg_fail(2)) SWIG_fail;
11109 }
11110 }
11111 if (obj2) {
11112 {
11113 arg3 = static_cast<int >(SWIG_As_int(obj2));
11114 if (SWIG_arg_fail(3)) SWIG_fail;
11115 }
11116 }
11117 {
11118 PyThreadState* __tstate = wxPyBeginAllowThreads();
11119 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
11120
11121 wxPyEndAllowThreads(__tstate);
11122 if (PyErr_Occurred()) SWIG_fail;
11123 }
11124 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11125 {
11126 if (temp1)
11127 delete arg1;
11128 }
11129 return resultobj;
11130 fail:
11131 {
11132 if (temp1)
11133 delete arg1;
11134 }
11135 return NULL;
11136 }
11137
11138
11139 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11140 PyObject *resultobj = NULL;
11141 wxImage *arg1 = (wxImage *) 0 ;
11142 PyObject * obj0 = 0 ;
11143 char *kwnames[] = {
11144 (char *) "self", NULL
11145 };
11146
11147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
11148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11149 if (SWIG_arg_fail(1)) SWIG_fail;
11150 {
11151 PyThreadState* __tstate = wxPyBeginAllowThreads();
11152 delete arg1;
11153
11154 wxPyEndAllowThreads(__tstate);
11155 if (PyErr_Occurred()) SWIG_fail;
11156 }
11157 Py_INCREF(Py_None); resultobj = Py_None;
11158 return resultobj;
11159 fail:
11160 return NULL;
11161 }
11162
11163
11164 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
11165 PyObject *resultobj = NULL;
11166 wxString *arg1 = 0 ;
11167 wxString *arg2 = 0 ;
11168 int arg3 = (int) -1 ;
11169 wxImage *result;
11170 bool temp1 = false ;
11171 bool temp2 = false ;
11172 PyObject * obj0 = 0 ;
11173 PyObject * obj1 = 0 ;
11174 PyObject * obj2 = 0 ;
11175 char *kwnames[] = {
11176 (char *) "name",(char *) "mimetype",(char *) "index", NULL
11177 };
11178
11179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11180 {
11181 arg1 = wxString_in_helper(obj0);
11182 if (arg1 == NULL) SWIG_fail;
11183 temp1 = true;
11184 }
11185 {
11186 arg2 = wxString_in_helper(obj1);
11187 if (arg2 == NULL) SWIG_fail;
11188 temp2 = true;
11189 }
11190 if (obj2) {
11191 {
11192 arg3 = static_cast<int >(SWIG_As_int(obj2));
11193 if (SWIG_arg_fail(3)) SWIG_fail;
11194 }
11195 }
11196 {
11197 PyThreadState* __tstate = wxPyBeginAllowThreads();
11198 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11199
11200 wxPyEndAllowThreads(__tstate);
11201 if (PyErr_Occurred()) SWIG_fail;
11202 }
11203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11204 {
11205 if (temp1)
11206 delete arg1;
11207 }
11208 {
11209 if (temp2)
11210 delete arg2;
11211 }
11212 return resultobj;
11213 fail:
11214 {
11215 if (temp1)
11216 delete arg1;
11217 }
11218 {
11219 if (temp2)
11220 delete arg2;
11221 }
11222 return NULL;
11223 }
11224
11225
11226 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
11227 PyObject *resultobj = NULL;
11228 wxInputStream *arg1 = 0 ;
11229 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11230 int arg3 = (int) -1 ;
11231 wxImage *result;
11232 wxPyInputStream *temp1 ;
11233 bool created1 ;
11234 PyObject * obj0 = 0 ;
11235 PyObject * obj1 = 0 ;
11236 PyObject * obj2 = 0 ;
11237 char *kwnames[] = {
11238 (char *) "stream",(char *) "type",(char *) "index", NULL
11239 };
11240
11241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
11242 {
11243 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11244 arg1 = temp1->m_wxis;
11245 created1 = false;
11246 } else {
11247 PyErr_Clear(); // clear the failure of the wxPyConvert above
11248 arg1 = wxPyCBInputStream_create(obj0, false);
11249 if (arg1 == NULL) {
11250 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11251 SWIG_fail;
11252 }
11253 created1 = true;
11254 }
11255 }
11256 if (obj1) {
11257 {
11258 arg2 = static_cast<long >(SWIG_As_long(obj1));
11259 if (SWIG_arg_fail(2)) SWIG_fail;
11260 }
11261 }
11262 if (obj2) {
11263 {
11264 arg3 = static_cast<int >(SWIG_As_int(obj2));
11265 if (SWIG_arg_fail(3)) SWIG_fail;
11266 }
11267 }
11268 {
11269 PyThreadState* __tstate = wxPyBeginAllowThreads();
11270 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
11271
11272 wxPyEndAllowThreads(__tstate);
11273 if (PyErr_Occurred()) SWIG_fail;
11274 }
11275 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11276 {
11277 if (created1) delete arg1;
11278 }
11279 return resultobj;
11280 fail:
11281 {
11282 if (created1) delete arg1;
11283 }
11284 return NULL;
11285 }
11286
11287
11288 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
11289 PyObject *resultobj = NULL;
11290 wxInputStream *arg1 = 0 ;
11291 wxString *arg2 = 0 ;
11292 int arg3 = (int) -1 ;
11293 wxImage *result;
11294 wxPyInputStream *temp1 ;
11295 bool created1 ;
11296 bool temp2 = false ;
11297 PyObject * obj0 = 0 ;
11298 PyObject * obj1 = 0 ;
11299 PyObject * obj2 = 0 ;
11300 char *kwnames[] = {
11301 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
11302 };
11303
11304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11305 {
11306 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11307 arg1 = temp1->m_wxis;
11308 created1 = false;
11309 } else {
11310 PyErr_Clear(); // clear the failure of the wxPyConvert above
11311 arg1 = wxPyCBInputStream_create(obj0, false);
11312 if (arg1 == NULL) {
11313 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11314 SWIG_fail;
11315 }
11316 created1 = true;
11317 }
11318 }
11319 {
11320 arg2 = wxString_in_helper(obj1);
11321 if (arg2 == NULL) SWIG_fail;
11322 temp2 = true;
11323 }
11324 if (obj2) {
11325 {
11326 arg3 = static_cast<int >(SWIG_As_int(obj2));
11327 if (SWIG_arg_fail(3)) SWIG_fail;
11328 }
11329 }
11330 {
11331 PyThreadState* __tstate = wxPyBeginAllowThreads();
11332 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
11333
11334 wxPyEndAllowThreads(__tstate);
11335 if (PyErr_Occurred()) SWIG_fail;
11336 }
11337 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11338 {
11339 if (created1) delete arg1;
11340 }
11341 {
11342 if (temp2)
11343 delete arg2;
11344 }
11345 return resultobj;
11346 fail:
11347 {
11348 if (created1) delete arg1;
11349 }
11350 {
11351 if (temp2)
11352 delete arg2;
11353 }
11354 return NULL;
11355 }
11356
11357
11358 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
11359 PyObject *resultobj = NULL;
11360 int arg1 = (int) 0 ;
11361 int arg2 = (int) 0 ;
11362 bool arg3 = (bool) true ;
11363 wxImage *result;
11364 PyObject * obj0 = 0 ;
11365 PyObject * obj1 = 0 ;
11366 PyObject * obj2 = 0 ;
11367 char *kwnames[] = {
11368 (char *) "width",(char *) "height",(char *) "clear", NULL
11369 };
11370
11371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
11372 if (obj0) {
11373 {
11374 arg1 = static_cast<int >(SWIG_As_int(obj0));
11375 if (SWIG_arg_fail(1)) SWIG_fail;
11376 }
11377 }
11378 if (obj1) {
11379 {
11380 arg2 = static_cast<int >(SWIG_As_int(obj1));
11381 if (SWIG_arg_fail(2)) SWIG_fail;
11382 }
11383 }
11384 if (obj2) {
11385 {
11386 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
11387 if (SWIG_arg_fail(3)) SWIG_fail;
11388 }
11389 }
11390 {
11391 PyThreadState* __tstate = wxPyBeginAllowThreads();
11392 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
11393
11394 wxPyEndAllowThreads(__tstate);
11395 if (PyErr_Occurred()) SWIG_fail;
11396 }
11397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11398 return resultobj;
11399 fail:
11400 return NULL;
11401 }
11402
11403
11404 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
11405 PyObject *resultobj = NULL;
11406 wxBitmap *arg1 = 0 ;
11407 wxImage *result;
11408 PyObject * obj0 = 0 ;
11409 char *kwnames[] = {
11410 (char *) "bitmap", NULL
11411 };
11412
11413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
11414 {
11415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
11416 if (SWIG_arg_fail(1)) SWIG_fail;
11417 if (arg1 == NULL) {
11418 SWIG_null_ref("wxBitmap");
11419 }
11420 if (SWIG_arg_fail(1)) SWIG_fail;
11421 }
11422 {
11423 if (!wxPyCheckForApp()) SWIG_fail;
11424 PyThreadState* __tstate = wxPyBeginAllowThreads();
11425 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
11426
11427 wxPyEndAllowThreads(__tstate);
11428 if (PyErr_Occurred()) SWIG_fail;
11429 }
11430 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11431 return resultobj;
11432 fail:
11433 return NULL;
11434 }
11435
11436
11437 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
11438 PyObject *resultobj = NULL;
11439 int arg1 ;
11440 int arg2 ;
11441 buffer arg3 ;
11442 int arg4 ;
11443 wxImage *result;
11444 PyObject * obj0 = 0 ;
11445 PyObject * obj1 = 0 ;
11446 PyObject * obj2 = 0 ;
11447 char *kwnames[] = {
11448 (char *) "width",(char *) "height",(char *) "data", NULL
11449 };
11450
11451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
11452 {
11453 arg1 = static_cast<int >(SWIG_As_int(obj0));
11454 if (SWIG_arg_fail(1)) SWIG_fail;
11455 }
11456 {
11457 arg2 = static_cast<int >(SWIG_As_int(obj1));
11458 if (SWIG_arg_fail(2)) SWIG_fail;
11459 }
11460 {
11461 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11462 }
11463 {
11464 PyThreadState* __tstate = wxPyBeginAllowThreads();
11465 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
11466
11467 wxPyEndAllowThreads(__tstate);
11468 if (PyErr_Occurred()) SWIG_fail;
11469 }
11470 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11471 return resultobj;
11472 fail:
11473 return NULL;
11474 }
11475
11476
11477 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11478 PyObject *resultobj = NULL;
11479 int arg1 ;
11480 int arg2 ;
11481 buffer arg3 ;
11482 int arg4 ;
11483 buffer arg5 ;
11484 int arg6 ;
11485 wxImage *result;
11486 PyObject * obj0 = 0 ;
11487 PyObject * obj1 = 0 ;
11488 PyObject * obj2 = 0 ;
11489 PyObject * obj3 = 0 ;
11490 char *kwnames[] = {
11491 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
11492 };
11493
11494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11495 {
11496 arg1 = static_cast<int >(SWIG_As_int(obj0));
11497 if (SWIG_arg_fail(1)) SWIG_fail;
11498 }
11499 {
11500 arg2 = static_cast<int >(SWIG_As_int(obj1));
11501 if (SWIG_arg_fail(2)) SWIG_fail;
11502 }
11503 {
11504 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11505 }
11506 {
11507 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
11508 }
11509 {
11510 PyThreadState* __tstate = wxPyBeginAllowThreads();
11511 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
11512
11513 wxPyEndAllowThreads(__tstate);
11514 if (PyErr_Occurred()) SWIG_fail;
11515 }
11516 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11517 return resultobj;
11518 fail:
11519 return NULL;
11520 }
11521
11522
11523 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11524 PyObject *resultobj = NULL;
11525 wxImage *arg1 = (wxImage *) 0 ;
11526 int arg2 ;
11527 int arg3 ;
11528 bool arg4 = (bool) true ;
11529 PyObject * obj0 = 0 ;
11530 PyObject * obj1 = 0 ;
11531 PyObject * obj2 = 0 ;
11532 PyObject * obj3 = 0 ;
11533 char *kwnames[] = {
11534 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
11535 };
11536
11537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11539 if (SWIG_arg_fail(1)) SWIG_fail;
11540 {
11541 arg2 = static_cast<int >(SWIG_As_int(obj1));
11542 if (SWIG_arg_fail(2)) SWIG_fail;
11543 }
11544 {
11545 arg3 = static_cast<int >(SWIG_As_int(obj2));
11546 if (SWIG_arg_fail(3)) SWIG_fail;
11547 }
11548 if (obj3) {
11549 {
11550 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
11551 if (SWIG_arg_fail(4)) SWIG_fail;
11552 }
11553 }
11554 {
11555 PyThreadState* __tstate = wxPyBeginAllowThreads();
11556 (arg1)->Create(arg2,arg3,arg4);
11557
11558 wxPyEndAllowThreads(__tstate);
11559 if (PyErr_Occurred()) SWIG_fail;
11560 }
11561 Py_INCREF(Py_None); resultobj = Py_None;
11562 return resultobj;
11563 fail:
11564 return NULL;
11565 }
11566
11567
11568 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
11569 PyObject *resultobj = NULL;
11570 wxImage *arg1 = (wxImage *) 0 ;
11571 PyObject * obj0 = 0 ;
11572 char *kwnames[] = {
11573 (char *) "self", NULL
11574 };
11575
11576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
11577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11578 if (SWIG_arg_fail(1)) SWIG_fail;
11579 {
11580 PyThreadState* __tstate = wxPyBeginAllowThreads();
11581 (arg1)->Destroy();
11582
11583 wxPyEndAllowThreads(__tstate);
11584 if (PyErr_Occurred()) SWIG_fail;
11585 }
11586 Py_INCREF(Py_None); resultobj = Py_None;
11587 return resultobj;
11588 fail:
11589 return NULL;
11590 }
11591
11592
11593 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
11594 PyObject *resultobj = NULL;
11595 wxImage *arg1 = (wxImage *) 0 ;
11596 int arg2 ;
11597 int arg3 ;
11598 SwigValueWrapper<wxImage > result;
11599 PyObject * obj0 = 0 ;
11600 PyObject * obj1 = 0 ;
11601 PyObject * obj2 = 0 ;
11602 char *kwnames[] = {
11603 (char *) "self",(char *) "width",(char *) "height", NULL
11604 };
11605
11606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11608 if (SWIG_arg_fail(1)) SWIG_fail;
11609 {
11610 arg2 = static_cast<int >(SWIG_As_int(obj1));
11611 if (SWIG_arg_fail(2)) SWIG_fail;
11612 }
11613 {
11614 arg3 = static_cast<int >(SWIG_As_int(obj2));
11615 if (SWIG_arg_fail(3)) SWIG_fail;
11616 }
11617 {
11618 PyThreadState* __tstate = wxPyBeginAllowThreads();
11619 result = (arg1)->Scale(arg2,arg3);
11620
11621 wxPyEndAllowThreads(__tstate);
11622 if (PyErr_Occurred()) SWIG_fail;
11623 }
11624 {
11625 wxImage * resultptr;
11626 resultptr = new wxImage(static_cast<wxImage & >(result));
11627 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11628 }
11629 return resultobj;
11630 fail:
11631 return NULL;
11632 }
11633
11634
11635 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11636 PyObject *resultobj = NULL;
11637 wxImage *arg1 = (wxImage *) 0 ;
11638 int arg2 ;
11639 int arg3 ;
11640 SwigValueWrapper<wxImage > result;
11641 PyObject * obj0 = 0 ;
11642 PyObject * obj1 = 0 ;
11643 PyObject * obj2 = 0 ;
11644 char *kwnames[] = {
11645 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11646 };
11647
11648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11650 if (SWIG_arg_fail(1)) SWIG_fail;
11651 {
11652 arg2 = static_cast<int >(SWIG_As_int(obj1));
11653 if (SWIG_arg_fail(2)) SWIG_fail;
11654 }
11655 {
11656 arg3 = static_cast<int >(SWIG_As_int(obj2));
11657 if (SWIG_arg_fail(3)) SWIG_fail;
11658 }
11659 {
11660 PyThreadState* __tstate = wxPyBeginAllowThreads();
11661 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11662
11663 wxPyEndAllowThreads(__tstate);
11664 if (PyErr_Occurred()) SWIG_fail;
11665 }
11666 {
11667 wxImage * resultptr;
11668 resultptr = new wxImage(static_cast<wxImage & >(result));
11669 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11670 }
11671 return resultobj;
11672 fail:
11673 return NULL;
11674 }
11675
11676
11677 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11678 PyObject *resultobj = NULL;
11679 wxImage *arg1 = (wxImage *) 0 ;
11680 int arg2 ;
11681 int arg3 ;
11682 wxImage *result;
11683 PyObject * obj0 = 0 ;
11684 PyObject * obj1 = 0 ;
11685 PyObject * obj2 = 0 ;
11686 char *kwnames[] = {
11687 (char *) "self",(char *) "width",(char *) "height", NULL
11688 };
11689
11690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11692 if (SWIG_arg_fail(1)) SWIG_fail;
11693 {
11694 arg2 = static_cast<int >(SWIG_As_int(obj1));
11695 if (SWIG_arg_fail(2)) SWIG_fail;
11696 }
11697 {
11698 arg3 = static_cast<int >(SWIG_As_int(obj2));
11699 if (SWIG_arg_fail(3)) SWIG_fail;
11700 }
11701 {
11702 PyThreadState* __tstate = wxPyBeginAllowThreads();
11703 {
11704 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11705 result = (wxImage *) &_result_ref;
11706 }
11707
11708 wxPyEndAllowThreads(__tstate);
11709 if (PyErr_Occurred()) SWIG_fail;
11710 }
11711 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11712 return resultobj;
11713 fail:
11714 return NULL;
11715 }
11716
11717
11718 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11719 PyObject *resultobj = NULL;
11720 wxImage *arg1 = (wxImage *) 0 ;
11721 wxSize *arg2 = 0 ;
11722 wxPoint *arg3 = 0 ;
11723 int arg4 = (int) -1 ;
11724 int arg5 = (int) -1 ;
11725 int arg6 = (int) -1 ;
11726 wxImage *result;
11727 wxSize temp2 ;
11728 wxPoint temp3 ;
11729 PyObject * obj0 = 0 ;
11730 PyObject * obj1 = 0 ;
11731 PyObject * obj2 = 0 ;
11732 PyObject * obj3 = 0 ;
11733 PyObject * obj4 = 0 ;
11734 PyObject * obj5 = 0 ;
11735 char *kwnames[] = {
11736 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11737 };
11738
11739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11741 if (SWIG_arg_fail(1)) SWIG_fail;
11742 {
11743 arg2 = &temp2;
11744 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11745 }
11746 {
11747 arg3 = &temp3;
11748 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11749 }
11750 if (obj3) {
11751 {
11752 arg4 = static_cast<int >(SWIG_As_int(obj3));
11753 if (SWIG_arg_fail(4)) SWIG_fail;
11754 }
11755 }
11756 if (obj4) {
11757 {
11758 arg5 = static_cast<int >(SWIG_As_int(obj4));
11759 if (SWIG_arg_fail(5)) SWIG_fail;
11760 }
11761 }
11762 if (obj5) {
11763 {
11764 arg6 = static_cast<int >(SWIG_As_int(obj5));
11765 if (SWIG_arg_fail(6)) SWIG_fail;
11766 }
11767 }
11768 {
11769 PyThreadState* __tstate = wxPyBeginAllowThreads();
11770 {
11771 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11772 result = (wxImage *) &_result_ref;
11773 }
11774
11775 wxPyEndAllowThreads(__tstate);
11776 if (PyErr_Occurred()) SWIG_fail;
11777 }
11778 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11779 return resultobj;
11780 fail:
11781 return NULL;
11782 }
11783
11784
11785 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11786 PyObject *resultobj = NULL;
11787 wxImage *arg1 = (wxImage *) 0 ;
11788 int arg2 ;
11789 int arg3 ;
11790 byte arg4 ;
11791 byte arg5 ;
11792 byte arg6 ;
11793 PyObject * obj0 = 0 ;
11794 PyObject * obj1 = 0 ;
11795 PyObject * obj2 = 0 ;
11796 PyObject * obj3 = 0 ;
11797 PyObject * obj4 = 0 ;
11798 PyObject * obj5 = 0 ;
11799 char *kwnames[] = {
11800 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11801 };
11802
11803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11805 if (SWIG_arg_fail(1)) SWIG_fail;
11806 {
11807 arg2 = static_cast<int >(SWIG_As_int(obj1));
11808 if (SWIG_arg_fail(2)) SWIG_fail;
11809 }
11810 {
11811 arg3 = static_cast<int >(SWIG_As_int(obj2));
11812 if (SWIG_arg_fail(3)) SWIG_fail;
11813 }
11814 {
11815 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
11816 if (SWIG_arg_fail(4)) SWIG_fail;
11817 }
11818 {
11819 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
11820 if (SWIG_arg_fail(5)) SWIG_fail;
11821 }
11822 {
11823 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj5));
11824 if (SWIG_arg_fail(6)) SWIG_fail;
11825 }
11826 {
11827 PyThreadState* __tstate = wxPyBeginAllowThreads();
11828 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11829
11830 wxPyEndAllowThreads(__tstate);
11831 if (PyErr_Occurred()) SWIG_fail;
11832 }
11833 Py_INCREF(Py_None); resultobj = Py_None;
11834 return resultobj;
11835 fail:
11836 return NULL;
11837 }
11838
11839
11840 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11841 PyObject *resultobj = NULL;
11842 wxImage *arg1 = (wxImage *) 0 ;
11843 wxRect *arg2 = 0 ;
11844 byte arg3 ;
11845 byte arg4 ;
11846 byte arg5 ;
11847 wxRect temp2 ;
11848 PyObject * obj0 = 0 ;
11849 PyObject * obj1 = 0 ;
11850 PyObject * obj2 = 0 ;
11851 PyObject * obj3 = 0 ;
11852 PyObject * obj4 = 0 ;
11853 char *kwnames[] = {
11854 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11855 };
11856
11857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11859 if (SWIG_arg_fail(1)) SWIG_fail;
11860 {
11861 arg2 = &temp2;
11862 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11863 }
11864 {
11865 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
11866 if (SWIG_arg_fail(3)) SWIG_fail;
11867 }
11868 {
11869 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
11870 if (SWIG_arg_fail(4)) SWIG_fail;
11871 }
11872 {
11873 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
11874 if (SWIG_arg_fail(5)) SWIG_fail;
11875 }
11876 {
11877 PyThreadState* __tstate = wxPyBeginAllowThreads();
11878 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11879
11880 wxPyEndAllowThreads(__tstate);
11881 if (PyErr_Occurred()) SWIG_fail;
11882 }
11883 Py_INCREF(Py_None); resultobj = Py_None;
11884 return resultobj;
11885 fail:
11886 return NULL;
11887 }
11888
11889
11890 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11891 PyObject *resultobj = NULL;
11892 wxImage *arg1 = (wxImage *) 0 ;
11893 int arg2 ;
11894 int arg3 ;
11895 byte result;
11896 PyObject * obj0 = 0 ;
11897 PyObject * obj1 = 0 ;
11898 PyObject * obj2 = 0 ;
11899 char *kwnames[] = {
11900 (char *) "self",(char *) "x",(char *) "y", NULL
11901 };
11902
11903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11905 if (SWIG_arg_fail(1)) SWIG_fail;
11906 {
11907 arg2 = static_cast<int >(SWIG_As_int(obj1));
11908 if (SWIG_arg_fail(2)) SWIG_fail;
11909 }
11910 {
11911 arg3 = static_cast<int >(SWIG_As_int(obj2));
11912 if (SWIG_arg_fail(3)) SWIG_fail;
11913 }
11914 {
11915 PyThreadState* __tstate = wxPyBeginAllowThreads();
11916 result = (byte)(arg1)->GetRed(arg2,arg3);
11917
11918 wxPyEndAllowThreads(__tstate);
11919 if (PyErr_Occurred()) SWIG_fail;
11920 }
11921 {
11922 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
11923 }
11924 return resultobj;
11925 fail:
11926 return NULL;
11927 }
11928
11929
11930 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11931 PyObject *resultobj = NULL;
11932 wxImage *arg1 = (wxImage *) 0 ;
11933 int arg2 ;
11934 int arg3 ;
11935 byte result;
11936 PyObject * obj0 = 0 ;
11937 PyObject * obj1 = 0 ;
11938 PyObject * obj2 = 0 ;
11939 char *kwnames[] = {
11940 (char *) "self",(char *) "x",(char *) "y", NULL
11941 };
11942
11943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11945 if (SWIG_arg_fail(1)) SWIG_fail;
11946 {
11947 arg2 = static_cast<int >(SWIG_As_int(obj1));
11948 if (SWIG_arg_fail(2)) SWIG_fail;
11949 }
11950 {
11951 arg3 = static_cast<int >(SWIG_As_int(obj2));
11952 if (SWIG_arg_fail(3)) SWIG_fail;
11953 }
11954 {
11955 PyThreadState* __tstate = wxPyBeginAllowThreads();
11956 result = (byte)(arg1)->GetGreen(arg2,arg3);
11957
11958 wxPyEndAllowThreads(__tstate);
11959 if (PyErr_Occurred()) SWIG_fail;
11960 }
11961 {
11962 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
11963 }
11964 return resultobj;
11965 fail:
11966 return NULL;
11967 }
11968
11969
11970 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11971 PyObject *resultobj = NULL;
11972 wxImage *arg1 = (wxImage *) 0 ;
11973 int arg2 ;
11974 int arg3 ;
11975 byte result;
11976 PyObject * obj0 = 0 ;
11977 PyObject * obj1 = 0 ;
11978 PyObject * obj2 = 0 ;
11979 char *kwnames[] = {
11980 (char *) "self",(char *) "x",(char *) "y", NULL
11981 };
11982
11983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11985 if (SWIG_arg_fail(1)) SWIG_fail;
11986 {
11987 arg2 = static_cast<int >(SWIG_As_int(obj1));
11988 if (SWIG_arg_fail(2)) SWIG_fail;
11989 }
11990 {
11991 arg3 = static_cast<int >(SWIG_As_int(obj2));
11992 if (SWIG_arg_fail(3)) SWIG_fail;
11993 }
11994 {
11995 PyThreadState* __tstate = wxPyBeginAllowThreads();
11996 result = (byte)(arg1)->GetBlue(arg2,arg3);
11997
11998 wxPyEndAllowThreads(__tstate);
11999 if (PyErr_Occurred()) SWIG_fail;
12000 }
12001 {
12002 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
12003 }
12004 return resultobj;
12005 fail:
12006 return NULL;
12007 }
12008
12009
12010 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12011 PyObject *resultobj = NULL;
12012 wxImage *arg1 = (wxImage *) 0 ;
12013 int arg2 ;
12014 int arg3 ;
12015 byte arg4 ;
12016 PyObject * obj0 = 0 ;
12017 PyObject * obj1 = 0 ;
12018 PyObject * obj2 = 0 ;
12019 PyObject * obj3 = 0 ;
12020 char *kwnames[] = {
12021 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
12022 };
12023
12024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12026 if (SWIG_arg_fail(1)) SWIG_fail;
12027 {
12028 arg2 = static_cast<int >(SWIG_As_int(obj1));
12029 if (SWIG_arg_fail(2)) SWIG_fail;
12030 }
12031 {
12032 arg3 = static_cast<int >(SWIG_As_int(obj2));
12033 if (SWIG_arg_fail(3)) SWIG_fail;
12034 }
12035 {
12036 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12037 if (SWIG_arg_fail(4)) SWIG_fail;
12038 }
12039 {
12040 PyThreadState* __tstate = wxPyBeginAllowThreads();
12041 (arg1)->SetAlpha(arg2,arg3,arg4);
12042
12043 wxPyEndAllowThreads(__tstate);
12044 if (PyErr_Occurred()) SWIG_fail;
12045 }
12046 Py_INCREF(Py_None); resultobj = Py_None;
12047 return resultobj;
12048 fail:
12049 return NULL;
12050 }
12051
12052
12053 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12054 PyObject *resultobj = NULL;
12055 wxImage *arg1 = (wxImage *) 0 ;
12056 int arg2 ;
12057 int arg3 ;
12058 byte result;
12059 PyObject * obj0 = 0 ;
12060 PyObject * obj1 = 0 ;
12061 PyObject * obj2 = 0 ;
12062 char *kwnames[] = {
12063 (char *) "self",(char *) "x",(char *) "y", NULL
12064 };
12065
12066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
12067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12068 if (SWIG_arg_fail(1)) SWIG_fail;
12069 {
12070 arg2 = static_cast<int >(SWIG_As_int(obj1));
12071 if (SWIG_arg_fail(2)) SWIG_fail;
12072 }
12073 {
12074 arg3 = static_cast<int >(SWIG_As_int(obj2));
12075 if (SWIG_arg_fail(3)) SWIG_fail;
12076 }
12077 {
12078 PyThreadState* __tstate = wxPyBeginAllowThreads();
12079 result = (byte)(arg1)->GetAlpha(arg2,arg3);
12080
12081 wxPyEndAllowThreads(__tstate);
12082 if (PyErr_Occurred()) SWIG_fail;
12083 }
12084 {
12085 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
12086 }
12087 return resultobj;
12088 fail:
12089 return NULL;
12090 }
12091
12092
12093 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12094 PyObject *resultobj = NULL;
12095 wxImage *arg1 = (wxImage *) 0 ;
12096 bool result;
12097 PyObject * obj0 = 0 ;
12098 char *kwnames[] = {
12099 (char *) "self", NULL
12100 };
12101
12102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
12103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12104 if (SWIG_arg_fail(1)) SWIG_fail;
12105 {
12106 PyThreadState* __tstate = wxPyBeginAllowThreads();
12107 result = (bool)(arg1)->HasAlpha();
12108
12109 wxPyEndAllowThreads(__tstate);
12110 if (PyErr_Occurred()) SWIG_fail;
12111 }
12112 {
12113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12114 }
12115 return resultobj;
12116 fail:
12117 return NULL;
12118 }
12119
12120
12121 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12122 PyObject *resultobj = NULL;
12123 wxImage *arg1 = (wxImage *) 0 ;
12124 PyObject * obj0 = 0 ;
12125 char *kwnames[] = {
12126 (char *) "self", NULL
12127 };
12128
12129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
12130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12131 if (SWIG_arg_fail(1)) SWIG_fail;
12132 {
12133 PyThreadState* __tstate = wxPyBeginAllowThreads();
12134 (arg1)->InitAlpha();
12135
12136 wxPyEndAllowThreads(__tstate);
12137 if (PyErr_Occurred()) SWIG_fail;
12138 }
12139 Py_INCREF(Py_None); resultobj = Py_None;
12140 return resultobj;
12141 fail:
12142 return NULL;
12143 }
12144
12145
12146 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
12147 PyObject *resultobj = NULL;
12148 wxImage *arg1 = (wxImage *) 0 ;
12149 int arg2 ;
12150 int arg3 ;
12151 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12152 bool result;
12153 PyObject * obj0 = 0 ;
12154 PyObject * obj1 = 0 ;
12155 PyObject * obj2 = 0 ;
12156 PyObject * obj3 = 0 ;
12157 char *kwnames[] = {
12158 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
12159 };
12160
12161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12163 if (SWIG_arg_fail(1)) SWIG_fail;
12164 {
12165 arg2 = static_cast<int >(SWIG_As_int(obj1));
12166 if (SWIG_arg_fail(2)) SWIG_fail;
12167 }
12168 {
12169 arg3 = static_cast<int >(SWIG_As_int(obj2));
12170 if (SWIG_arg_fail(3)) SWIG_fail;
12171 }
12172 if (obj3) {
12173 {
12174 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12175 if (SWIG_arg_fail(4)) SWIG_fail;
12176 }
12177 }
12178 {
12179 PyThreadState* __tstate = wxPyBeginAllowThreads();
12180 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
12181
12182 wxPyEndAllowThreads(__tstate);
12183 if (PyErr_Occurred()) SWIG_fail;
12184 }
12185 {
12186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12187 }
12188 return resultobj;
12189 fail:
12190 return NULL;
12191 }
12192
12193
12194 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
12195 PyObject *resultobj = NULL;
12196 wxImage *arg1 = (wxImage *) 0 ;
12197 byte *arg2 = (byte *) 0 ;
12198 byte *arg3 = (byte *) 0 ;
12199 byte *arg4 = (byte *) 0 ;
12200 byte arg5 = (byte) 0 ;
12201 byte arg6 = (byte) 0 ;
12202 byte arg7 = (byte) 0 ;
12203 bool result;
12204 byte temp2 ;
12205 int res2 = 0 ;
12206 byte temp3 ;
12207 int res3 = 0 ;
12208 byte temp4 ;
12209 int res4 = 0 ;
12210 PyObject * obj0 = 0 ;
12211 PyObject * obj1 = 0 ;
12212 PyObject * obj2 = 0 ;
12213 PyObject * obj3 = 0 ;
12214 char *kwnames[] = {
12215 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12216 };
12217
12218 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12219 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12220 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12223 if (SWIG_arg_fail(1)) SWIG_fail;
12224 if (obj1) {
12225 {
12226 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12227 if (SWIG_arg_fail(5)) SWIG_fail;
12228 }
12229 }
12230 if (obj2) {
12231 {
12232 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12233 if (SWIG_arg_fail(6)) SWIG_fail;
12234 }
12235 }
12236 if (obj3) {
12237 {
12238 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12239 if (SWIG_arg_fail(7)) SWIG_fail;
12240 }
12241 }
12242 {
12243 PyThreadState* __tstate = wxPyBeginAllowThreads();
12244 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12245
12246 wxPyEndAllowThreads(__tstate);
12247 if (PyErr_Occurred()) SWIG_fail;
12248 }
12249 {
12250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12251 }
12252 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12253 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12254 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12255 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12256 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12257 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12258 return resultobj;
12259 fail:
12260 return NULL;
12261 }
12262
12263
12264 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
12265 PyObject *resultobj = NULL;
12266 wxImage *arg1 = (wxImage *) 0 ;
12267 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12268 bool result;
12269 PyObject * obj0 = 0 ;
12270 PyObject * obj1 = 0 ;
12271 char *kwnames[] = {
12272 (char *) "self",(char *) "threshold", NULL
12273 };
12274
12275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
12276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12277 if (SWIG_arg_fail(1)) SWIG_fail;
12278 if (obj1) {
12279 {
12280 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12281 if (SWIG_arg_fail(2)) SWIG_fail;
12282 }
12283 }
12284 {
12285 PyThreadState* __tstate = wxPyBeginAllowThreads();
12286 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
12287
12288 wxPyEndAllowThreads(__tstate);
12289 if (PyErr_Occurred()) SWIG_fail;
12290 }
12291 {
12292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12293 }
12294 return resultobj;
12295 fail:
12296 return NULL;
12297 }
12298
12299
12300 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12301 PyObject *resultobj = NULL;
12302 wxImage *arg1 = (wxImage *) 0 ;
12303 byte arg2 ;
12304 byte arg3 ;
12305 byte arg4 ;
12306 bool result;
12307 PyObject * obj0 = 0 ;
12308 PyObject * obj1 = 0 ;
12309 PyObject * obj2 = 0 ;
12310 PyObject * obj3 = 0 ;
12311 char *kwnames[] = {
12312 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12313 };
12314
12315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12317 if (SWIG_arg_fail(1)) SWIG_fail;
12318 {
12319 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12320 if (SWIG_arg_fail(2)) SWIG_fail;
12321 }
12322 {
12323 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12324 if (SWIG_arg_fail(3)) SWIG_fail;
12325 }
12326 {
12327 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12328 if (SWIG_arg_fail(4)) SWIG_fail;
12329 }
12330 {
12331 PyThreadState* __tstate = wxPyBeginAllowThreads();
12332 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
12333
12334 wxPyEndAllowThreads(__tstate);
12335 if (PyErr_Occurred()) SWIG_fail;
12336 }
12337 {
12338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12339 }
12340 return resultobj;
12341 fail:
12342 return NULL;
12343 }
12344
12345
12346 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
12347 PyObject *resultobj = NULL;
12348 wxImage *arg1 = (wxImage *) 0 ;
12349 wxImage *arg2 = 0 ;
12350 byte arg3 ;
12351 byte arg4 ;
12352 byte arg5 ;
12353 bool result;
12354 PyObject * obj0 = 0 ;
12355 PyObject * obj1 = 0 ;
12356 PyObject * obj2 = 0 ;
12357 PyObject * obj3 = 0 ;
12358 PyObject * obj4 = 0 ;
12359 char *kwnames[] = {
12360 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
12361 };
12362
12363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12365 if (SWIG_arg_fail(1)) SWIG_fail;
12366 {
12367 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12368 if (SWIG_arg_fail(2)) SWIG_fail;
12369 if (arg2 == NULL) {
12370 SWIG_null_ref("wxImage");
12371 }
12372 if (SWIG_arg_fail(2)) SWIG_fail;
12373 }
12374 {
12375 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12376 if (SWIG_arg_fail(3)) SWIG_fail;
12377 }
12378 {
12379 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12380 if (SWIG_arg_fail(4)) SWIG_fail;
12381 }
12382 {
12383 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
12384 if (SWIG_arg_fail(5)) SWIG_fail;
12385 }
12386 {
12387 PyThreadState* __tstate = wxPyBeginAllowThreads();
12388 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
12389
12390 wxPyEndAllowThreads(__tstate);
12391 if (PyErr_Occurred()) SWIG_fail;
12392 }
12393 {
12394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12395 }
12396 return resultobj;
12397 fail:
12398 return NULL;
12399 }
12400
12401
12402 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
12403 PyObject *resultobj = NULL;
12404 wxString *arg1 = 0 ;
12405 bool result;
12406 bool temp1 = false ;
12407 PyObject * obj0 = 0 ;
12408 char *kwnames[] = {
12409 (char *) "filename", NULL
12410 };
12411
12412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
12413 {
12414 arg1 = wxString_in_helper(obj0);
12415 if (arg1 == NULL) SWIG_fail;
12416 temp1 = true;
12417 }
12418 {
12419 PyThreadState* __tstate = wxPyBeginAllowThreads();
12420 result = (bool)wxImage::CanRead((wxString const &)*arg1);
12421
12422 wxPyEndAllowThreads(__tstate);
12423 if (PyErr_Occurred()) SWIG_fail;
12424 }
12425 {
12426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12427 }
12428 {
12429 if (temp1)
12430 delete arg1;
12431 }
12432 return resultobj;
12433 fail:
12434 {
12435 if (temp1)
12436 delete arg1;
12437 }
12438 return NULL;
12439 }
12440
12441
12442 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
12443 PyObject *resultobj = NULL;
12444 wxString *arg1 = 0 ;
12445 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12446 int result;
12447 bool temp1 = false ;
12448 PyObject * obj0 = 0 ;
12449 PyObject * obj1 = 0 ;
12450 char *kwnames[] = {
12451 (char *) "filename",(char *) "type", NULL
12452 };
12453
12454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
12455 {
12456 arg1 = wxString_in_helper(obj0);
12457 if (arg1 == NULL) SWIG_fail;
12458 temp1 = true;
12459 }
12460 if (obj1) {
12461 {
12462 arg2 = static_cast<long >(SWIG_As_long(obj1));
12463 if (SWIG_arg_fail(2)) SWIG_fail;
12464 }
12465 }
12466 {
12467 PyThreadState* __tstate = wxPyBeginAllowThreads();
12468 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
12469
12470 wxPyEndAllowThreads(__tstate);
12471 if (PyErr_Occurred()) SWIG_fail;
12472 }
12473 {
12474 resultobj = SWIG_From_int(static_cast<int >(result));
12475 }
12476 {
12477 if (temp1)
12478 delete arg1;
12479 }
12480 return resultobj;
12481 fail:
12482 {
12483 if (temp1)
12484 delete arg1;
12485 }
12486 return NULL;
12487 }
12488
12489
12490 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
12491 PyObject *resultobj = NULL;
12492 wxImage *arg1 = (wxImage *) 0 ;
12493 wxString *arg2 = 0 ;
12494 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12495 int arg4 = (int) -1 ;
12496 bool result;
12497 bool temp2 = false ;
12498 PyObject * obj0 = 0 ;
12499 PyObject * obj1 = 0 ;
12500 PyObject * obj2 = 0 ;
12501 PyObject * obj3 = 0 ;
12502 char *kwnames[] = {
12503 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
12504 };
12505
12506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12508 if (SWIG_arg_fail(1)) SWIG_fail;
12509 {
12510 arg2 = wxString_in_helper(obj1);
12511 if (arg2 == NULL) SWIG_fail;
12512 temp2 = true;
12513 }
12514 if (obj2) {
12515 {
12516 arg3 = static_cast<long >(SWIG_As_long(obj2));
12517 if (SWIG_arg_fail(3)) SWIG_fail;
12518 }
12519 }
12520 if (obj3) {
12521 {
12522 arg4 = static_cast<int >(SWIG_As_int(obj3));
12523 if (SWIG_arg_fail(4)) SWIG_fail;
12524 }
12525 }
12526 {
12527 PyThreadState* __tstate = wxPyBeginAllowThreads();
12528 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
12529
12530 wxPyEndAllowThreads(__tstate);
12531 if (PyErr_Occurred()) SWIG_fail;
12532 }
12533 {
12534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12535 }
12536 {
12537 if (temp2)
12538 delete arg2;
12539 }
12540 return resultobj;
12541 fail:
12542 {
12543 if (temp2)
12544 delete arg2;
12545 }
12546 return NULL;
12547 }
12548
12549
12550 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12551 PyObject *resultobj = NULL;
12552 wxImage *arg1 = (wxImage *) 0 ;
12553 wxString *arg2 = 0 ;
12554 wxString *arg3 = 0 ;
12555 int arg4 = (int) -1 ;
12556 bool result;
12557 bool temp2 = false ;
12558 bool temp3 = false ;
12559 PyObject * obj0 = 0 ;
12560 PyObject * obj1 = 0 ;
12561 PyObject * obj2 = 0 ;
12562 PyObject * obj3 = 0 ;
12563 char *kwnames[] = {
12564 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
12565 };
12566
12567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12569 if (SWIG_arg_fail(1)) SWIG_fail;
12570 {
12571 arg2 = wxString_in_helper(obj1);
12572 if (arg2 == NULL) SWIG_fail;
12573 temp2 = true;
12574 }
12575 {
12576 arg3 = wxString_in_helper(obj2);
12577 if (arg3 == NULL) SWIG_fail;
12578 temp3 = true;
12579 }
12580 if (obj3) {
12581 {
12582 arg4 = static_cast<int >(SWIG_As_int(obj3));
12583 if (SWIG_arg_fail(4)) SWIG_fail;
12584 }
12585 }
12586 {
12587 PyThreadState* __tstate = wxPyBeginAllowThreads();
12588 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
12589
12590 wxPyEndAllowThreads(__tstate);
12591 if (PyErr_Occurred()) SWIG_fail;
12592 }
12593 {
12594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12595 }
12596 {
12597 if (temp2)
12598 delete arg2;
12599 }
12600 {
12601 if (temp3)
12602 delete arg3;
12603 }
12604 return resultobj;
12605 fail:
12606 {
12607 if (temp2)
12608 delete arg2;
12609 }
12610 {
12611 if (temp3)
12612 delete arg3;
12613 }
12614 return NULL;
12615 }
12616
12617
12618 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12619 PyObject *resultobj = NULL;
12620 wxImage *arg1 = (wxImage *) 0 ;
12621 wxString *arg2 = 0 ;
12622 int arg3 ;
12623 bool result;
12624 bool temp2 = false ;
12625 PyObject * obj0 = 0 ;
12626 PyObject * obj1 = 0 ;
12627 PyObject * obj2 = 0 ;
12628 char *kwnames[] = {
12629 (char *) "self",(char *) "name",(char *) "type", NULL
12630 };
12631
12632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12634 if (SWIG_arg_fail(1)) SWIG_fail;
12635 {
12636 arg2 = wxString_in_helper(obj1);
12637 if (arg2 == NULL) SWIG_fail;
12638 temp2 = true;
12639 }
12640 {
12641 arg3 = static_cast<int >(SWIG_As_int(obj2));
12642 if (SWIG_arg_fail(3)) SWIG_fail;
12643 }
12644 {
12645 PyThreadState* __tstate = wxPyBeginAllowThreads();
12646 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12647
12648 wxPyEndAllowThreads(__tstate);
12649 if (PyErr_Occurred()) SWIG_fail;
12650 }
12651 {
12652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12653 }
12654 {
12655 if (temp2)
12656 delete arg2;
12657 }
12658 return resultobj;
12659 fail:
12660 {
12661 if (temp2)
12662 delete arg2;
12663 }
12664 return NULL;
12665 }
12666
12667
12668 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12669 PyObject *resultobj = NULL;
12670 wxImage *arg1 = (wxImage *) 0 ;
12671 wxString *arg2 = 0 ;
12672 wxString *arg3 = 0 ;
12673 bool result;
12674 bool temp2 = false ;
12675 bool temp3 = false ;
12676 PyObject * obj0 = 0 ;
12677 PyObject * obj1 = 0 ;
12678 PyObject * obj2 = 0 ;
12679 char *kwnames[] = {
12680 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12681 };
12682
12683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12685 if (SWIG_arg_fail(1)) SWIG_fail;
12686 {
12687 arg2 = wxString_in_helper(obj1);
12688 if (arg2 == NULL) SWIG_fail;
12689 temp2 = true;
12690 }
12691 {
12692 arg3 = wxString_in_helper(obj2);
12693 if (arg3 == NULL) SWIG_fail;
12694 temp3 = true;
12695 }
12696 {
12697 PyThreadState* __tstate = wxPyBeginAllowThreads();
12698 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12699
12700 wxPyEndAllowThreads(__tstate);
12701 if (PyErr_Occurred()) SWIG_fail;
12702 }
12703 {
12704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12705 }
12706 {
12707 if (temp2)
12708 delete arg2;
12709 }
12710 {
12711 if (temp3)
12712 delete arg3;
12713 }
12714 return resultobj;
12715 fail:
12716 {
12717 if (temp2)
12718 delete arg2;
12719 }
12720 {
12721 if (temp3)
12722 delete arg3;
12723 }
12724 return NULL;
12725 }
12726
12727
12728 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12729 PyObject *resultobj = NULL;
12730 wxInputStream *arg1 = 0 ;
12731 bool result;
12732 wxPyInputStream *temp1 ;
12733 bool created1 ;
12734 PyObject * obj0 = 0 ;
12735 char *kwnames[] = {
12736 (char *) "stream", NULL
12737 };
12738
12739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12740 {
12741 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12742 arg1 = temp1->m_wxis;
12743 created1 = false;
12744 } else {
12745 PyErr_Clear(); // clear the failure of the wxPyConvert above
12746 arg1 = wxPyCBInputStream_create(obj0, false);
12747 if (arg1 == NULL) {
12748 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12749 SWIG_fail;
12750 }
12751 created1 = true;
12752 }
12753 }
12754 {
12755 PyThreadState* __tstate = wxPyBeginAllowThreads();
12756 result = (bool)wxImage::CanRead(*arg1);
12757
12758 wxPyEndAllowThreads(__tstate);
12759 if (PyErr_Occurred()) SWIG_fail;
12760 }
12761 {
12762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12763 }
12764 {
12765 if (created1) delete arg1;
12766 }
12767 return resultobj;
12768 fail:
12769 {
12770 if (created1) delete arg1;
12771 }
12772 return NULL;
12773 }
12774
12775
12776 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12777 PyObject *resultobj = NULL;
12778 wxImage *arg1 = (wxImage *) 0 ;
12779 wxInputStream *arg2 = 0 ;
12780 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12781 int arg4 = (int) -1 ;
12782 bool result;
12783 wxPyInputStream *temp2 ;
12784 bool created2 ;
12785 PyObject * obj0 = 0 ;
12786 PyObject * obj1 = 0 ;
12787 PyObject * obj2 = 0 ;
12788 PyObject * obj3 = 0 ;
12789 char *kwnames[] = {
12790 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12791 };
12792
12793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12795 if (SWIG_arg_fail(1)) SWIG_fail;
12796 {
12797 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12798 arg2 = temp2->m_wxis;
12799 created2 = false;
12800 } else {
12801 PyErr_Clear(); // clear the failure of the wxPyConvert above
12802 arg2 = wxPyCBInputStream_create(obj1, false);
12803 if (arg2 == NULL) {
12804 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12805 SWIG_fail;
12806 }
12807 created2 = true;
12808 }
12809 }
12810 if (obj2) {
12811 {
12812 arg3 = static_cast<long >(SWIG_As_long(obj2));
12813 if (SWIG_arg_fail(3)) SWIG_fail;
12814 }
12815 }
12816 if (obj3) {
12817 {
12818 arg4 = static_cast<int >(SWIG_As_int(obj3));
12819 if (SWIG_arg_fail(4)) SWIG_fail;
12820 }
12821 }
12822 {
12823 PyThreadState* __tstate = wxPyBeginAllowThreads();
12824 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12825
12826 wxPyEndAllowThreads(__tstate);
12827 if (PyErr_Occurred()) SWIG_fail;
12828 }
12829 {
12830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12831 }
12832 {
12833 if (created2) delete arg2;
12834 }
12835 return resultobj;
12836 fail:
12837 {
12838 if (created2) delete arg2;
12839 }
12840 return NULL;
12841 }
12842
12843
12844 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12845 PyObject *resultobj = NULL;
12846 wxImage *arg1 = (wxImage *) 0 ;
12847 wxInputStream *arg2 = 0 ;
12848 wxString *arg3 = 0 ;
12849 int arg4 = (int) -1 ;
12850 bool result;
12851 wxPyInputStream *temp2 ;
12852 bool created2 ;
12853 bool temp3 = false ;
12854 PyObject * obj0 = 0 ;
12855 PyObject * obj1 = 0 ;
12856 PyObject * obj2 = 0 ;
12857 PyObject * obj3 = 0 ;
12858 char *kwnames[] = {
12859 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12860 };
12861
12862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12864 if (SWIG_arg_fail(1)) SWIG_fail;
12865 {
12866 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12867 arg2 = temp2->m_wxis;
12868 created2 = false;
12869 } else {
12870 PyErr_Clear(); // clear the failure of the wxPyConvert above
12871 arg2 = wxPyCBInputStream_create(obj1, false);
12872 if (arg2 == NULL) {
12873 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12874 SWIG_fail;
12875 }
12876 created2 = true;
12877 }
12878 }
12879 {
12880 arg3 = wxString_in_helper(obj2);
12881 if (arg3 == NULL) SWIG_fail;
12882 temp3 = true;
12883 }
12884 if (obj3) {
12885 {
12886 arg4 = static_cast<int >(SWIG_As_int(obj3));
12887 if (SWIG_arg_fail(4)) SWIG_fail;
12888 }
12889 }
12890 {
12891 PyThreadState* __tstate = wxPyBeginAllowThreads();
12892 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12893
12894 wxPyEndAllowThreads(__tstate);
12895 if (PyErr_Occurred()) SWIG_fail;
12896 }
12897 {
12898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12899 }
12900 {
12901 if (created2) delete arg2;
12902 }
12903 {
12904 if (temp3)
12905 delete arg3;
12906 }
12907 return resultobj;
12908 fail:
12909 {
12910 if (created2) delete arg2;
12911 }
12912 {
12913 if (temp3)
12914 delete arg3;
12915 }
12916 return NULL;
12917 }
12918
12919
12920 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12921 PyObject *resultobj = NULL;
12922 wxImage *arg1 = (wxImage *) 0 ;
12923 bool result;
12924 PyObject * obj0 = 0 ;
12925 char *kwnames[] = {
12926 (char *) "self", NULL
12927 };
12928
12929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12931 if (SWIG_arg_fail(1)) SWIG_fail;
12932 {
12933 PyThreadState* __tstate = wxPyBeginAllowThreads();
12934 result = (bool)(arg1)->Ok();
12935
12936 wxPyEndAllowThreads(__tstate);
12937 if (PyErr_Occurred()) SWIG_fail;
12938 }
12939 {
12940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12941 }
12942 return resultobj;
12943 fail:
12944 return NULL;
12945 }
12946
12947
12948 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12949 PyObject *resultobj = NULL;
12950 wxImage *arg1 = (wxImage *) 0 ;
12951 int result;
12952 PyObject * obj0 = 0 ;
12953 char *kwnames[] = {
12954 (char *) "self", NULL
12955 };
12956
12957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12959 if (SWIG_arg_fail(1)) SWIG_fail;
12960 {
12961 PyThreadState* __tstate = wxPyBeginAllowThreads();
12962 result = (int)(arg1)->GetWidth();
12963
12964 wxPyEndAllowThreads(__tstate);
12965 if (PyErr_Occurred()) SWIG_fail;
12966 }
12967 {
12968 resultobj = SWIG_From_int(static_cast<int >(result));
12969 }
12970 return resultobj;
12971 fail:
12972 return NULL;
12973 }
12974
12975
12976 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12977 PyObject *resultobj = NULL;
12978 wxImage *arg1 = (wxImage *) 0 ;
12979 int result;
12980 PyObject * obj0 = 0 ;
12981 char *kwnames[] = {
12982 (char *) "self", NULL
12983 };
12984
12985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12987 if (SWIG_arg_fail(1)) SWIG_fail;
12988 {
12989 PyThreadState* __tstate = wxPyBeginAllowThreads();
12990 result = (int)(arg1)->GetHeight();
12991
12992 wxPyEndAllowThreads(__tstate);
12993 if (PyErr_Occurred()) SWIG_fail;
12994 }
12995 {
12996 resultobj = SWIG_From_int(static_cast<int >(result));
12997 }
12998 return resultobj;
12999 fail:
13000 return NULL;
13001 }
13002
13003
13004 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
13005 PyObject *resultobj = NULL;
13006 wxImage *arg1 = (wxImage *) 0 ;
13007 wxSize result;
13008 PyObject * obj0 = 0 ;
13009 char *kwnames[] = {
13010 (char *) "self", NULL
13011 };
13012
13013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
13014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13015 if (SWIG_arg_fail(1)) SWIG_fail;
13016 {
13017 PyThreadState* __tstate = wxPyBeginAllowThreads();
13018 result = wxImage_GetSize(arg1);
13019
13020 wxPyEndAllowThreads(__tstate);
13021 if (PyErr_Occurred()) SWIG_fail;
13022 }
13023 {
13024 wxSize * resultptr;
13025 resultptr = new wxSize(static_cast<wxSize & >(result));
13026 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
13027 }
13028 return resultobj;
13029 fail:
13030 return NULL;
13031 }
13032
13033
13034 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
13035 PyObject *resultobj = NULL;
13036 wxImage *arg1 = (wxImage *) 0 ;
13037 wxRect *arg2 = 0 ;
13038 SwigValueWrapper<wxImage > result;
13039 wxRect temp2 ;
13040 PyObject * obj0 = 0 ;
13041 PyObject * obj1 = 0 ;
13042 char *kwnames[] = {
13043 (char *) "self",(char *) "rect", NULL
13044 };
13045
13046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
13047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13048 if (SWIG_arg_fail(1)) SWIG_fail;
13049 {
13050 arg2 = &temp2;
13051 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13052 }
13053 {
13054 PyThreadState* __tstate = wxPyBeginAllowThreads();
13055 result = (arg1)->GetSubImage((wxRect const &)*arg2);
13056
13057 wxPyEndAllowThreads(__tstate);
13058 if (PyErr_Occurred()) SWIG_fail;
13059 }
13060 {
13061 wxImage * resultptr;
13062 resultptr = new wxImage(static_cast<wxImage & >(result));
13063 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13064 }
13065 return resultobj;
13066 fail:
13067 return NULL;
13068 }
13069
13070
13071 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
13072 PyObject *resultobj = NULL;
13073 wxImage *arg1 = (wxImage *) 0 ;
13074 wxSize *arg2 = 0 ;
13075 wxPoint *arg3 = 0 ;
13076 int arg4 = (int) -1 ;
13077 int arg5 = (int) -1 ;
13078 int arg6 = (int) -1 ;
13079 SwigValueWrapper<wxImage > result;
13080 wxSize temp2 ;
13081 wxPoint temp3 ;
13082 PyObject * obj0 = 0 ;
13083 PyObject * obj1 = 0 ;
13084 PyObject * obj2 = 0 ;
13085 PyObject * obj3 = 0 ;
13086 PyObject * obj4 = 0 ;
13087 PyObject * obj5 = 0 ;
13088 char *kwnames[] = {
13089 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13090 };
13091
13092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13094 if (SWIG_arg_fail(1)) SWIG_fail;
13095 {
13096 arg2 = &temp2;
13097 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13098 }
13099 {
13100 arg3 = &temp3;
13101 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13102 }
13103 if (obj3) {
13104 {
13105 arg4 = static_cast<int >(SWIG_As_int(obj3));
13106 if (SWIG_arg_fail(4)) SWIG_fail;
13107 }
13108 }
13109 if (obj4) {
13110 {
13111 arg5 = static_cast<int >(SWIG_As_int(obj4));
13112 if (SWIG_arg_fail(5)) SWIG_fail;
13113 }
13114 }
13115 if (obj5) {
13116 {
13117 arg6 = static_cast<int >(SWIG_As_int(obj5));
13118 if (SWIG_arg_fail(6)) SWIG_fail;
13119 }
13120 }
13121 {
13122 PyThreadState* __tstate = wxPyBeginAllowThreads();
13123 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13124
13125 wxPyEndAllowThreads(__tstate);
13126 if (PyErr_Occurred()) SWIG_fail;
13127 }
13128 {
13129 wxImage * resultptr;
13130 resultptr = new wxImage(static_cast<wxImage & >(result));
13131 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13132 }
13133 return resultobj;
13134 fail:
13135 return NULL;
13136 }
13137
13138
13139 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
13140 PyObject *resultobj = NULL;
13141 wxImage *arg1 = (wxImage *) 0 ;
13142 SwigValueWrapper<wxImage > result;
13143 PyObject * obj0 = 0 ;
13144 char *kwnames[] = {
13145 (char *) "self", NULL
13146 };
13147
13148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
13149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13150 if (SWIG_arg_fail(1)) SWIG_fail;
13151 {
13152 PyThreadState* __tstate = wxPyBeginAllowThreads();
13153 result = (arg1)->Copy();
13154
13155 wxPyEndAllowThreads(__tstate);
13156 if (PyErr_Occurred()) SWIG_fail;
13157 }
13158 {
13159 wxImage * resultptr;
13160 resultptr = new wxImage(static_cast<wxImage & >(result));
13161 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13162 }
13163 return resultobj;
13164 fail:
13165 return NULL;
13166 }
13167
13168
13169 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
13170 PyObject *resultobj = NULL;
13171 wxImage *arg1 = (wxImage *) 0 ;
13172 wxImage *arg2 = 0 ;
13173 int arg3 ;
13174 int arg4 ;
13175 PyObject * obj0 = 0 ;
13176 PyObject * obj1 = 0 ;
13177 PyObject * obj2 = 0 ;
13178 PyObject * obj3 = 0 ;
13179 char *kwnames[] = {
13180 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
13181 };
13182
13183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13185 if (SWIG_arg_fail(1)) SWIG_fail;
13186 {
13187 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13188 if (SWIG_arg_fail(2)) SWIG_fail;
13189 if (arg2 == NULL) {
13190 SWIG_null_ref("wxImage");
13191 }
13192 if (SWIG_arg_fail(2)) SWIG_fail;
13193 }
13194 {
13195 arg3 = static_cast<int >(SWIG_As_int(obj2));
13196 if (SWIG_arg_fail(3)) SWIG_fail;
13197 }
13198 {
13199 arg4 = static_cast<int >(SWIG_As_int(obj3));
13200 if (SWIG_arg_fail(4)) SWIG_fail;
13201 }
13202 {
13203 PyThreadState* __tstate = wxPyBeginAllowThreads();
13204 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
13205
13206 wxPyEndAllowThreads(__tstate);
13207 if (PyErr_Occurred()) SWIG_fail;
13208 }
13209 Py_INCREF(Py_None); resultobj = Py_None;
13210 return resultobj;
13211 fail:
13212 return NULL;
13213 }
13214
13215
13216 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
13217 PyObject *resultobj = NULL;
13218 wxImage *arg1 = (wxImage *) 0 ;
13219 PyObject *result;
13220 PyObject * obj0 = 0 ;
13221 char *kwnames[] = {
13222 (char *) "self", NULL
13223 };
13224
13225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
13226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13227 if (SWIG_arg_fail(1)) SWIG_fail;
13228 {
13229 PyThreadState* __tstate = wxPyBeginAllowThreads();
13230 result = (PyObject *)wxImage_GetData(arg1);
13231
13232 wxPyEndAllowThreads(__tstate);
13233 if (PyErr_Occurred()) SWIG_fail;
13234 }
13235 resultobj = result;
13236 return resultobj;
13237 fail:
13238 return NULL;
13239 }
13240
13241
13242 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
13243 PyObject *resultobj = NULL;
13244 wxImage *arg1 = (wxImage *) 0 ;
13245 buffer arg2 ;
13246 int arg3 ;
13247 PyObject * obj0 = 0 ;
13248 PyObject * obj1 = 0 ;
13249 char *kwnames[] = {
13250 (char *) "self",(char *) "data", NULL
13251 };
13252
13253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
13254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13255 if (SWIG_arg_fail(1)) SWIG_fail;
13256 {
13257 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13258 }
13259 {
13260 PyThreadState* __tstate = wxPyBeginAllowThreads();
13261 wxImage_SetData(arg1,arg2,arg3);
13262
13263 wxPyEndAllowThreads(__tstate);
13264 if (PyErr_Occurred()) SWIG_fail;
13265 }
13266 Py_INCREF(Py_None); resultobj = Py_None;
13267 return resultobj;
13268 fail:
13269 return NULL;
13270 }
13271
13272
13273 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13274 PyObject *resultobj = NULL;
13275 wxImage *arg1 = (wxImage *) 0 ;
13276 PyObject *result;
13277 PyObject * obj0 = 0 ;
13278 char *kwnames[] = {
13279 (char *) "self", NULL
13280 };
13281
13282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
13283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13284 if (SWIG_arg_fail(1)) SWIG_fail;
13285 {
13286 PyThreadState* __tstate = wxPyBeginAllowThreads();
13287 result = (PyObject *)wxImage_GetDataBuffer(arg1);
13288
13289 wxPyEndAllowThreads(__tstate);
13290 if (PyErr_Occurred()) SWIG_fail;
13291 }
13292 resultobj = result;
13293 return resultobj;
13294 fail:
13295 return NULL;
13296 }
13297
13298
13299 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13300 PyObject *resultobj = NULL;
13301 wxImage *arg1 = (wxImage *) 0 ;
13302 buffer arg2 ;
13303 int arg3 ;
13304 PyObject * obj0 = 0 ;
13305 PyObject * obj1 = 0 ;
13306 char *kwnames[] = {
13307 (char *) "self",(char *) "data", NULL
13308 };
13309
13310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
13311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13312 if (SWIG_arg_fail(1)) SWIG_fail;
13313 {
13314 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13315 }
13316 {
13317 PyThreadState* __tstate = wxPyBeginAllowThreads();
13318 wxImage_SetDataBuffer(arg1,arg2,arg3);
13319
13320 wxPyEndAllowThreads(__tstate);
13321 if (PyErr_Occurred()) SWIG_fail;
13322 }
13323 Py_INCREF(Py_None); resultobj = Py_None;
13324 return resultobj;
13325 fail:
13326 return NULL;
13327 }
13328
13329
13330 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13331 PyObject *resultobj = NULL;
13332 wxImage *arg1 = (wxImage *) 0 ;
13333 PyObject *result;
13334 PyObject * obj0 = 0 ;
13335 char *kwnames[] = {
13336 (char *) "self", NULL
13337 };
13338
13339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
13340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13341 if (SWIG_arg_fail(1)) SWIG_fail;
13342 {
13343 PyThreadState* __tstate = wxPyBeginAllowThreads();
13344 result = (PyObject *)wxImage_GetAlphaData(arg1);
13345
13346 wxPyEndAllowThreads(__tstate);
13347 if (PyErr_Occurred()) SWIG_fail;
13348 }
13349 resultobj = result;
13350 return resultobj;
13351 fail:
13352 return NULL;
13353 }
13354
13355
13356 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13357 PyObject *resultobj = NULL;
13358 wxImage *arg1 = (wxImage *) 0 ;
13359 buffer arg2 ;
13360 int arg3 ;
13361 PyObject * obj0 = 0 ;
13362 PyObject * obj1 = 0 ;
13363 char *kwnames[] = {
13364 (char *) "self",(char *) "alpha", NULL
13365 };
13366
13367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
13368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13369 if (SWIG_arg_fail(1)) SWIG_fail;
13370 {
13371 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13372 }
13373 {
13374 PyThreadState* __tstate = wxPyBeginAllowThreads();
13375 wxImage_SetAlphaData(arg1,arg2,arg3);
13376
13377 wxPyEndAllowThreads(__tstate);
13378 if (PyErr_Occurred()) SWIG_fail;
13379 }
13380 Py_INCREF(Py_None); resultobj = Py_None;
13381 return resultobj;
13382 fail:
13383 return NULL;
13384 }
13385
13386
13387 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13388 PyObject *resultobj = NULL;
13389 wxImage *arg1 = (wxImage *) 0 ;
13390 PyObject *result;
13391 PyObject * obj0 = 0 ;
13392 char *kwnames[] = {
13393 (char *) "self", NULL
13394 };
13395
13396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
13397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13398 if (SWIG_arg_fail(1)) SWIG_fail;
13399 {
13400 PyThreadState* __tstate = wxPyBeginAllowThreads();
13401 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
13402
13403 wxPyEndAllowThreads(__tstate);
13404 if (PyErr_Occurred()) SWIG_fail;
13405 }
13406 resultobj = result;
13407 return resultobj;
13408 fail:
13409 return NULL;
13410 }
13411
13412
13413 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13414 PyObject *resultobj = NULL;
13415 wxImage *arg1 = (wxImage *) 0 ;
13416 buffer arg2 ;
13417 int arg3 ;
13418 PyObject * obj0 = 0 ;
13419 PyObject * obj1 = 0 ;
13420 char *kwnames[] = {
13421 (char *) "self",(char *) "alpha", NULL
13422 };
13423
13424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
13425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13426 if (SWIG_arg_fail(1)) SWIG_fail;
13427 {
13428 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13429 }
13430 {
13431 PyThreadState* __tstate = wxPyBeginAllowThreads();
13432 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
13433
13434 wxPyEndAllowThreads(__tstate);
13435 if (PyErr_Occurred()) SWIG_fail;
13436 }
13437 Py_INCREF(Py_None); resultobj = Py_None;
13438 return resultobj;
13439 fail:
13440 return NULL;
13441 }
13442
13443
13444 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13445 PyObject *resultobj = NULL;
13446 wxImage *arg1 = (wxImage *) 0 ;
13447 byte arg2 ;
13448 byte arg3 ;
13449 byte arg4 ;
13450 PyObject * obj0 = 0 ;
13451 PyObject * obj1 = 0 ;
13452 PyObject * obj2 = 0 ;
13453 PyObject * obj3 = 0 ;
13454 char *kwnames[] = {
13455 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13456 };
13457
13458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13460 if (SWIG_arg_fail(1)) SWIG_fail;
13461 {
13462 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13463 if (SWIG_arg_fail(2)) SWIG_fail;
13464 }
13465 {
13466 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13467 if (SWIG_arg_fail(3)) SWIG_fail;
13468 }
13469 {
13470 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13471 if (SWIG_arg_fail(4)) SWIG_fail;
13472 }
13473 {
13474 PyThreadState* __tstate = wxPyBeginAllowThreads();
13475 (arg1)->SetMaskColour(arg2,arg3,arg4);
13476
13477 wxPyEndAllowThreads(__tstate);
13478 if (PyErr_Occurred()) SWIG_fail;
13479 }
13480 Py_INCREF(Py_None); resultobj = Py_None;
13481 return resultobj;
13482 fail:
13483 return NULL;
13484 }
13485
13486
13487 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13488 PyObject *resultobj = NULL;
13489 wxImage *arg1 = (wxImage *) 0 ;
13490 byte *arg2 = (byte *) 0 ;
13491 byte *arg3 = (byte *) 0 ;
13492 byte *arg4 = (byte *) 0 ;
13493 byte temp2 ;
13494 int res2 = 0 ;
13495 byte temp3 ;
13496 int res3 = 0 ;
13497 byte temp4 ;
13498 int res4 = 0 ;
13499 PyObject * obj0 = 0 ;
13500 char *kwnames[] = {
13501 (char *) "self", NULL
13502 };
13503
13504 arg2 = &temp2; res2 = SWIG_NEWOBJ;
13505 arg3 = &temp3; res3 = SWIG_NEWOBJ;
13506 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
13508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13509 if (SWIG_arg_fail(1)) SWIG_fail;
13510 {
13511 PyThreadState* __tstate = wxPyBeginAllowThreads();
13512 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
13513
13514 wxPyEndAllowThreads(__tstate);
13515 if (PyErr_Occurred()) SWIG_fail;
13516 }
13517 Py_INCREF(Py_None); resultobj = Py_None;
13518 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
13519 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
13520 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
13521 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
13522 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13523 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
13524 return resultobj;
13525 fail:
13526 return NULL;
13527 }
13528
13529
13530 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
13531 PyObject *resultobj = NULL;
13532 wxImage *arg1 = (wxImage *) 0 ;
13533 byte result;
13534 PyObject * obj0 = 0 ;
13535 char *kwnames[] = {
13536 (char *) "self", NULL
13537 };
13538
13539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
13540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13541 if (SWIG_arg_fail(1)) SWIG_fail;
13542 {
13543 PyThreadState* __tstate = wxPyBeginAllowThreads();
13544 result = (byte)(arg1)->GetMaskRed();
13545
13546 wxPyEndAllowThreads(__tstate);
13547 if (PyErr_Occurred()) SWIG_fail;
13548 }
13549 {
13550 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13551 }
13552 return resultobj;
13553 fail:
13554 return NULL;
13555 }
13556
13557
13558 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
13559 PyObject *resultobj = NULL;
13560 wxImage *arg1 = (wxImage *) 0 ;
13561 byte result;
13562 PyObject * obj0 = 0 ;
13563 char *kwnames[] = {
13564 (char *) "self", NULL
13565 };
13566
13567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
13568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13569 if (SWIG_arg_fail(1)) SWIG_fail;
13570 {
13571 PyThreadState* __tstate = wxPyBeginAllowThreads();
13572 result = (byte)(arg1)->GetMaskGreen();
13573
13574 wxPyEndAllowThreads(__tstate);
13575 if (PyErr_Occurred()) SWIG_fail;
13576 }
13577 {
13578 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13579 }
13580 return resultobj;
13581 fail:
13582 return NULL;
13583 }
13584
13585
13586 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
13587 PyObject *resultobj = NULL;
13588 wxImage *arg1 = (wxImage *) 0 ;
13589 byte result;
13590 PyObject * obj0 = 0 ;
13591 char *kwnames[] = {
13592 (char *) "self", NULL
13593 };
13594
13595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
13596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13597 if (SWIG_arg_fail(1)) SWIG_fail;
13598 {
13599 PyThreadState* __tstate = wxPyBeginAllowThreads();
13600 result = (byte)(arg1)->GetMaskBlue();
13601
13602 wxPyEndAllowThreads(__tstate);
13603 if (PyErr_Occurred()) SWIG_fail;
13604 }
13605 {
13606 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13607 }
13608 return resultobj;
13609 fail:
13610 return NULL;
13611 }
13612
13613
13614 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
13615 PyObject *resultobj = NULL;
13616 wxImage *arg1 = (wxImage *) 0 ;
13617 bool arg2 = (bool) true ;
13618 PyObject * obj0 = 0 ;
13619 PyObject * obj1 = 0 ;
13620 char *kwnames[] = {
13621 (char *) "self",(char *) "mask", NULL
13622 };
13623
13624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13626 if (SWIG_arg_fail(1)) SWIG_fail;
13627 if (obj1) {
13628 {
13629 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13630 if (SWIG_arg_fail(2)) SWIG_fail;
13631 }
13632 }
13633 {
13634 PyThreadState* __tstate = wxPyBeginAllowThreads();
13635 (arg1)->SetMask(arg2);
13636
13637 wxPyEndAllowThreads(__tstate);
13638 if (PyErr_Occurred()) SWIG_fail;
13639 }
13640 Py_INCREF(Py_None); resultobj = Py_None;
13641 return resultobj;
13642 fail:
13643 return NULL;
13644 }
13645
13646
13647 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13648 PyObject *resultobj = NULL;
13649 wxImage *arg1 = (wxImage *) 0 ;
13650 bool result;
13651 PyObject * obj0 = 0 ;
13652 char *kwnames[] = {
13653 (char *) "self", NULL
13654 };
13655
13656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13658 if (SWIG_arg_fail(1)) SWIG_fail;
13659 {
13660 PyThreadState* __tstate = wxPyBeginAllowThreads();
13661 result = (bool)(arg1)->HasMask();
13662
13663 wxPyEndAllowThreads(__tstate);
13664 if (PyErr_Occurred()) SWIG_fail;
13665 }
13666 {
13667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13668 }
13669 return resultobj;
13670 fail:
13671 return NULL;
13672 }
13673
13674
13675 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13676 PyObject *resultobj = NULL;
13677 wxImage *arg1 = (wxImage *) 0 ;
13678 double arg2 ;
13679 wxPoint *arg3 = 0 ;
13680 bool arg4 = (bool) true ;
13681 wxPoint *arg5 = (wxPoint *) NULL ;
13682 SwigValueWrapper<wxImage > result;
13683 wxPoint temp3 ;
13684 PyObject * obj0 = 0 ;
13685 PyObject * obj1 = 0 ;
13686 PyObject * obj2 = 0 ;
13687 PyObject * obj3 = 0 ;
13688 PyObject * obj4 = 0 ;
13689 char *kwnames[] = {
13690 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13691 };
13692
13693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13695 if (SWIG_arg_fail(1)) SWIG_fail;
13696 {
13697 arg2 = static_cast<double >(SWIG_As_double(obj1));
13698 if (SWIG_arg_fail(2)) SWIG_fail;
13699 }
13700 {
13701 arg3 = &temp3;
13702 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13703 }
13704 if (obj3) {
13705 {
13706 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
13707 if (SWIG_arg_fail(4)) SWIG_fail;
13708 }
13709 }
13710 if (obj4) {
13711 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13712 if (SWIG_arg_fail(5)) SWIG_fail;
13713 }
13714 {
13715 PyThreadState* __tstate = wxPyBeginAllowThreads();
13716 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13717
13718 wxPyEndAllowThreads(__tstate);
13719 if (PyErr_Occurred()) SWIG_fail;
13720 }
13721 {
13722 wxImage * resultptr;
13723 resultptr = new wxImage(static_cast<wxImage & >(result));
13724 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13725 }
13726 return resultobj;
13727 fail:
13728 return NULL;
13729 }
13730
13731
13732 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13733 PyObject *resultobj = NULL;
13734 wxImage *arg1 = (wxImage *) 0 ;
13735 bool arg2 = (bool) true ;
13736 SwigValueWrapper<wxImage > result;
13737 PyObject * obj0 = 0 ;
13738 PyObject * obj1 = 0 ;
13739 char *kwnames[] = {
13740 (char *) "self",(char *) "clockwise", NULL
13741 };
13742
13743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13745 if (SWIG_arg_fail(1)) SWIG_fail;
13746 if (obj1) {
13747 {
13748 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13749 if (SWIG_arg_fail(2)) SWIG_fail;
13750 }
13751 }
13752 {
13753 PyThreadState* __tstate = wxPyBeginAllowThreads();
13754 result = (arg1)->Rotate90(arg2);
13755
13756 wxPyEndAllowThreads(__tstate);
13757 if (PyErr_Occurred()) SWIG_fail;
13758 }
13759 {
13760 wxImage * resultptr;
13761 resultptr = new wxImage(static_cast<wxImage & >(result));
13762 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13763 }
13764 return resultobj;
13765 fail:
13766 return NULL;
13767 }
13768
13769
13770 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13771 PyObject *resultobj = NULL;
13772 wxImage *arg1 = (wxImage *) 0 ;
13773 bool arg2 = (bool) true ;
13774 SwigValueWrapper<wxImage > result;
13775 PyObject * obj0 = 0 ;
13776 PyObject * obj1 = 0 ;
13777 char *kwnames[] = {
13778 (char *) "self",(char *) "horizontally", NULL
13779 };
13780
13781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13783 if (SWIG_arg_fail(1)) SWIG_fail;
13784 if (obj1) {
13785 {
13786 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13787 if (SWIG_arg_fail(2)) SWIG_fail;
13788 }
13789 }
13790 {
13791 PyThreadState* __tstate = wxPyBeginAllowThreads();
13792 result = (arg1)->Mirror(arg2);
13793
13794 wxPyEndAllowThreads(__tstate);
13795 if (PyErr_Occurred()) SWIG_fail;
13796 }
13797 {
13798 wxImage * resultptr;
13799 resultptr = new wxImage(static_cast<wxImage & >(result));
13800 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13801 }
13802 return resultobj;
13803 fail:
13804 return NULL;
13805 }
13806
13807
13808 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13809 PyObject *resultobj = NULL;
13810 wxImage *arg1 = (wxImage *) 0 ;
13811 byte arg2 ;
13812 byte arg3 ;
13813 byte arg4 ;
13814 byte arg5 ;
13815 byte arg6 ;
13816 byte arg7 ;
13817 PyObject * obj0 = 0 ;
13818 PyObject * obj1 = 0 ;
13819 PyObject * obj2 = 0 ;
13820 PyObject * obj3 = 0 ;
13821 PyObject * obj4 = 0 ;
13822 PyObject * obj5 = 0 ;
13823 PyObject * obj6 = 0 ;
13824 char *kwnames[] = {
13825 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13826 };
13827
13828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13830 if (SWIG_arg_fail(1)) SWIG_fail;
13831 {
13832 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13833 if (SWIG_arg_fail(2)) SWIG_fail;
13834 }
13835 {
13836 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13837 if (SWIG_arg_fail(3)) SWIG_fail;
13838 }
13839 {
13840 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13841 if (SWIG_arg_fail(4)) SWIG_fail;
13842 }
13843 {
13844 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
13845 if (SWIG_arg_fail(5)) SWIG_fail;
13846 }
13847 {
13848 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj5));
13849 if (SWIG_arg_fail(6)) SWIG_fail;
13850 }
13851 {
13852 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj6));
13853 if (SWIG_arg_fail(7)) SWIG_fail;
13854 }
13855 {
13856 PyThreadState* __tstate = wxPyBeginAllowThreads();
13857 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13858
13859 wxPyEndAllowThreads(__tstate);
13860 if (PyErr_Occurred()) SWIG_fail;
13861 }
13862 Py_INCREF(Py_None); resultobj = Py_None;
13863 return resultobj;
13864 fail:
13865 return NULL;
13866 }
13867
13868
13869 static PyObject *_wrap_Image_ConvertToGreyscale(PyObject *, PyObject *args, PyObject *kwargs) {
13870 PyObject *resultobj = NULL;
13871 wxImage *arg1 = (wxImage *) 0 ;
13872 double arg2 = (double) 0.299 ;
13873 double arg3 = (double) 0.587 ;
13874 double arg4 = (double) 0.114 ;
13875 SwigValueWrapper<wxImage > result;
13876 PyObject * obj0 = 0 ;
13877 PyObject * obj1 = 0 ;
13878 PyObject * obj2 = 0 ;
13879 PyObject * obj3 = 0 ;
13880 char *kwnames[] = {
13881 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
13882 };
13883
13884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13886 if (SWIG_arg_fail(1)) SWIG_fail;
13887 if (obj1) {
13888 {
13889 arg2 = static_cast<double >(SWIG_As_double(obj1));
13890 if (SWIG_arg_fail(2)) SWIG_fail;
13891 }
13892 }
13893 if (obj2) {
13894 {
13895 arg3 = static_cast<double >(SWIG_As_double(obj2));
13896 if (SWIG_arg_fail(3)) SWIG_fail;
13897 }
13898 }
13899 if (obj3) {
13900 {
13901 arg4 = static_cast<double >(SWIG_As_double(obj3));
13902 if (SWIG_arg_fail(4)) SWIG_fail;
13903 }
13904 }
13905 {
13906 PyThreadState* __tstate = wxPyBeginAllowThreads();
13907 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
13908
13909 wxPyEndAllowThreads(__tstate);
13910 if (PyErr_Occurred()) SWIG_fail;
13911 }
13912 {
13913 wxImage * resultptr;
13914 resultptr = new wxImage(static_cast<wxImage & >(result));
13915 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13916 }
13917 return resultobj;
13918 fail:
13919 return NULL;
13920 }
13921
13922
13923 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13924 PyObject *resultobj = NULL;
13925 wxImage *arg1 = (wxImage *) 0 ;
13926 byte arg2 ;
13927 byte arg3 ;
13928 byte arg4 ;
13929 SwigValueWrapper<wxImage > result;
13930 PyObject * obj0 = 0 ;
13931 PyObject * obj1 = 0 ;
13932 PyObject * obj2 = 0 ;
13933 PyObject * obj3 = 0 ;
13934 char *kwnames[] = {
13935 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13936 };
13937
13938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13940 if (SWIG_arg_fail(1)) SWIG_fail;
13941 {
13942 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13943 if (SWIG_arg_fail(2)) SWIG_fail;
13944 }
13945 {
13946 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13947 if (SWIG_arg_fail(3)) SWIG_fail;
13948 }
13949 {
13950 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13951 if (SWIG_arg_fail(4)) SWIG_fail;
13952 }
13953 {
13954 PyThreadState* __tstate = wxPyBeginAllowThreads();
13955 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13956
13957 wxPyEndAllowThreads(__tstate);
13958 if (PyErr_Occurred()) SWIG_fail;
13959 }
13960 {
13961 wxImage * resultptr;
13962 resultptr = new wxImage(static_cast<wxImage & >(result));
13963 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13964 }
13965 return resultobj;
13966 fail:
13967 return NULL;
13968 }
13969
13970
13971 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13972 PyObject *resultobj = NULL;
13973 wxImage *arg1 = (wxImage *) 0 ;
13974 wxString *arg2 = 0 ;
13975 wxString *arg3 = 0 ;
13976 bool temp2 = false ;
13977 bool temp3 = false ;
13978 PyObject * obj0 = 0 ;
13979 PyObject * obj1 = 0 ;
13980 PyObject * obj2 = 0 ;
13981 char *kwnames[] = {
13982 (char *) "self",(char *) "name",(char *) "value", NULL
13983 };
13984
13985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13987 if (SWIG_arg_fail(1)) SWIG_fail;
13988 {
13989 arg2 = wxString_in_helper(obj1);
13990 if (arg2 == NULL) SWIG_fail;
13991 temp2 = true;
13992 }
13993 {
13994 arg3 = wxString_in_helper(obj2);
13995 if (arg3 == NULL) SWIG_fail;
13996 temp3 = true;
13997 }
13998 {
13999 PyThreadState* __tstate = wxPyBeginAllowThreads();
14000 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
14001
14002 wxPyEndAllowThreads(__tstate);
14003 if (PyErr_Occurred()) SWIG_fail;
14004 }
14005 Py_INCREF(Py_None); resultobj = Py_None;
14006 {
14007 if (temp2)
14008 delete arg2;
14009 }
14010 {
14011 if (temp3)
14012 delete arg3;
14013 }
14014 return resultobj;
14015 fail:
14016 {
14017 if (temp2)
14018 delete arg2;
14019 }
14020 {
14021 if (temp3)
14022 delete arg3;
14023 }
14024 return NULL;
14025 }
14026
14027
14028 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
14029 PyObject *resultobj = NULL;
14030 wxImage *arg1 = (wxImage *) 0 ;
14031 wxString *arg2 = 0 ;
14032 int arg3 ;
14033 bool temp2 = false ;
14034 PyObject * obj0 = 0 ;
14035 PyObject * obj1 = 0 ;
14036 PyObject * obj2 = 0 ;
14037 char *kwnames[] = {
14038 (char *) "self",(char *) "name",(char *) "value", NULL
14039 };
14040
14041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
14042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14043 if (SWIG_arg_fail(1)) SWIG_fail;
14044 {
14045 arg2 = wxString_in_helper(obj1);
14046 if (arg2 == NULL) SWIG_fail;
14047 temp2 = true;
14048 }
14049 {
14050 arg3 = static_cast<int >(SWIG_As_int(obj2));
14051 if (SWIG_arg_fail(3)) SWIG_fail;
14052 }
14053 {
14054 PyThreadState* __tstate = wxPyBeginAllowThreads();
14055 (arg1)->SetOption((wxString const &)*arg2,arg3);
14056
14057 wxPyEndAllowThreads(__tstate);
14058 if (PyErr_Occurred()) SWIG_fail;
14059 }
14060 Py_INCREF(Py_None); resultobj = Py_None;
14061 {
14062 if (temp2)
14063 delete arg2;
14064 }
14065 return resultobj;
14066 fail:
14067 {
14068 if (temp2)
14069 delete arg2;
14070 }
14071 return NULL;
14072 }
14073
14074
14075 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
14076 PyObject *resultobj = NULL;
14077 wxImage *arg1 = (wxImage *) 0 ;
14078 wxString *arg2 = 0 ;
14079 wxString result;
14080 bool temp2 = false ;
14081 PyObject * obj0 = 0 ;
14082 PyObject * obj1 = 0 ;
14083 char *kwnames[] = {
14084 (char *) "self",(char *) "name", NULL
14085 };
14086
14087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
14088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14089 if (SWIG_arg_fail(1)) SWIG_fail;
14090 {
14091 arg2 = wxString_in_helper(obj1);
14092 if (arg2 == NULL) SWIG_fail;
14093 temp2 = true;
14094 }
14095 {
14096 PyThreadState* __tstate = wxPyBeginAllowThreads();
14097 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
14098
14099 wxPyEndAllowThreads(__tstate);
14100 if (PyErr_Occurred()) SWIG_fail;
14101 }
14102 {
14103 #if wxUSE_UNICODE
14104 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14105 #else
14106 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14107 #endif
14108 }
14109 {
14110 if (temp2)
14111 delete arg2;
14112 }
14113 return resultobj;
14114 fail:
14115 {
14116 if (temp2)
14117 delete arg2;
14118 }
14119 return NULL;
14120 }
14121
14122
14123 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
14124 PyObject *resultobj = NULL;
14125 wxImage *arg1 = (wxImage *) 0 ;
14126 wxString *arg2 = 0 ;
14127 int result;
14128 bool temp2 = false ;
14129 PyObject * obj0 = 0 ;
14130 PyObject * obj1 = 0 ;
14131 char *kwnames[] = {
14132 (char *) "self",(char *) "name", NULL
14133 };
14134
14135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
14136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14137 if (SWIG_arg_fail(1)) SWIG_fail;
14138 {
14139 arg2 = wxString_in_helper(obj1);
14140 if (arg2 == NULL) SWIG_fail;
14141 temp2 = true;
14142 }
14143 {
14144 PyThreadState* __tstate = wxPyBeginAllowThreads();
14145 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
14146
14147 wxPyEndAllowThreads(__tstate);
14148 if (PyErr_Occurred()) SWIG_fail;
14149 }
14150 {
14151 resultobj = SWIG_From_int(static_cast<int >(result));
14152 }
14153 {
14154 if (temp2)
14155 delete arg2;
14156 }
14157 return resultobj;
14158 fail:
14159 {
14160 if (temp2)
14161 delete arg2;
14162 }
14163 return NULL;
14164 }
14165
14166
14167 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
14168 PyObject *resultobj = NULL;
14169 wxImage *arg1 = (wxImage *) 0 ;
14170 wxString *arg2 = 0 ;
14171 bool result;
14172 bool temp2 = false ;
14173 PyObject * obj0 = 0 ;
14174 PyObject * obj1 = 0 ;
14175 char *kwnames[] = {
14176 (char *) "self",(char *) "name", NULL
14177 };
14178
14179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
14180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14181 if (SWIG_arg_fail(1)) SWIG_fail;
14182 {
14183 arg2 = wxString_in_helper(obj1);
14184 if (arg2 == NULL) SWIG_fail;
14185 temp2 = true;
14186 }
14187 {
14188 PyThreadState* __tstate = wxPyBeginAllowThreads();
14189 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
14190
14191 wxPyEndAllowThreads(__tstate);
14192 if (PyErr_Occurred()) SWIG_fail;
14193 }
14194 {
14195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14196 }
14197 {
14198 if (temp2)
14199 delete arg2;
14200 }
14201 return resultobj;
14202 fail:
14203 {
14204 if (temp2)
14205 delete arg2;
14206 }
14207 return NULL;
14208 }
14209
14210
14211 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
14212 PyObject *resultobj = NULL;
14213 wxImage *arg1 = (wxImage *) 0 ;
14214 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
14215 unsigned long result;
14216 PyObject * obj0 = 0 ;
14217 PyObject * obj1 = 0 ;
14218 char *kwnames[] = {
14219 (char *) "self",(char *) "stopafter", NULL
14220 };
14221
14222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
14223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14224 if (SWIG_arg_fail(1)) SWIG_fail;
14225 if (obj1) {
14226 {
14227 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
14228 if (SWIG_arg_fail(2)) SWIG_fail;
14229 }
14230 }
14231 {
14232 PyThreadState* __tstate = wxPyBeginAllowThreads();
14233 result = (unsigned long)(arg1)->CountColours(arg2);
14234
14235 wxPyEndAllowThreads(__tstate);
14236 if (PyErr_Occurred()) SWIG_fail;
14237 }
14238 {
14239 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
14240 }
14241 return resultobj;
14242 fail:
14243 return NULL;
14244 }
14245
14246
14247 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
14248 PyObject *resultobj = NULL;
14249 wxImage *arg1 = (wxImage *) 0 ;
14250 wxImageHistogram *arg2 = 0 ;
14251 unsigned long result;
14252 PyObject * obj0 = 0 ;
14253 PyObject * obj1 = 0 ;
14254 char *kwnames[] = {
14255 (char *) "self",(char *) "h", NULL
14256 };
14257
14258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
14259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14260 if (SWIG_arg_fail(1)) SWIG_fail;
14261 {
14262 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
14263 if (SWIG_arg_fail(2)) SWIG_fail;
14264 if (arg2 == NULL) {
14265 SWIG_null_ref("wxImageHistogram");
14266 }
14267 if (SWIG_arg_fail(2)) SWIG_fail;
14268 }
14269 {
14270 PyThreadState* __tstate = wxPyBeginAllowThreads();
14271 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
14272
14273 wxPyEndAllowThreads(__tstate);
14274 if (PyErr_Occurred()) SWIG_fail;
14275 }
14276 {
14277 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
14278 }
14279 return resultobj;
14280 fail:
14281 return NULL;
14282 }
14283
14284
14285 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14286 PyObject *resultobj = NULL;
14287 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14288 PyObject * obj0 = 0 ;
14289 char *kwnames[] = {
14290 (char *) "handler", NULL
14291 };
14292
14293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
14294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14295 if (SWIG_arg_fail(1)) SWIG_fail;
14296 {
14297 PyThreadState* __tstate = wxPyBeginAllowThreads();
14298 wxImage::AddHandler(arg1);
14299
14300 wxPyEndAllowThreads(__tstate);
14301 if (PyErr_Occurred()) SWIG_fail;
14302 }
14303 Py_INCREF(Py_None); resultobj = Py_None;
14304 return resultobj;
14305 fail:
14306 return NULL;
14307 }
14308
14309
14310 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14311 PyObject *resultobj = NULL;
14312 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14313 PyObject * obj0 = 0 ;
14314 char *kwnames[] = {
14315 (char *) "handler", NULL
14316 };
14317
14318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
14319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14320 if (SWIG_arg_fail(1)) SWIG_fail;
14321 {
14322 PyThreadState* __tstate = wxPyBeginAllowThreads();
14323 wxImage::InsertHandler(arg1);
14324
14325 wxPyEndAllowThreads(__tstate);
14326 if (PyErr_Occurred()) SWIG_fail;
14327 }
14328 Py_INCREF(Py_None); resultobj = Py_None;
14329 return resultobj;
14330 fail:
14331 return NULL;
14332 }
14333
14334
14335 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14336 PyObject *resultobj = NULL;
14337 wxString *arg1 = 0 ;
14338 bool result;
14339 bool temp1 = false ;
14340 PyObject * obj0 = 0 ;
14341 char *kwnames[] = {
14342 (char *) "name", NULL
14343 };
14344
14345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
14346 {
14347 arg1 = wxString_in_helper(obj0);
14348 if (arg1 == NULL) SWIG_fail;
14349 temp1 = true;
14350 }
14351 {
14352 PyThreadState* __tstate = wxPyBeginAllowThreads();
14353 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
14354
14355 wxPyEndAllowThreads(__tstate);
14356 if (PyErr_Occurred()) SWIG_fail;
14357 }
14358 {
14359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14360 }
14361 {
14362 if (temp1)
14363 delete arg1;
14364 }
14365 return resultobj;
14366 fail:
14367 {
14368 if (temp1)
14369 delete arg1;
14370 }
14371 return NULL;
14372 }
14373
14374
14375 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14376 PyObject *resultobj = NULL;
14377 wxString result;
14378 char *kwnames[] = {
14379 NULL
14380 };
14381
14382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
14383 {
14384 PyThreadState* __tstate = wxPyBeginAllowThreads();
14385 result = wxImage::GetImageExtWildcard();
14386
14387 wxPyEndAllowThreads(__tstate);
14388 if (PyErr_Occurred()) SWIG_fail;
14389 }
14390 {
14391 #if wxUSE_UNICODE
14392 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14393 #else
14394 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14395 #endif
14396 }
14397 return resultobj;
14398 fail:
14399 return NULL;
14400 }
14401
14402
14403 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14404 PyObject *resultobj = NULL;
14405 wxImage *arg1 = (wxImage *) 0 ;
14406 int arg2 = (int) -1 ;
14407 wxBitmap result;
14408 PyObject * obj0 = 0 ;
14409 PyObject * obj1 = 0 ;
14410 char *kwnames[] = {
14411 (char *) "self",(char *) "depth", NULL
14412 };
14413
14414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
14415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14416 if (SWIG_arg_fail(1)) SWIG_fail;
14417 if (obj1) {
14418 {
14419 arg2 = static_cast<int >(SWIG_As_int(obj1));
14420 if (SWIG_arg_fail(2)) SWIG_fail;
14421 }
14422 }
14423 {
14424 if (!wxPyCheckForApp()) SWIG_fail;
14425 PyThreadState* __tstate = wxPyBeginAllowThreads();
14426 result = wxImage_ConvertToBitmap(arg1,arg2);
14427
14428 wxPyEndAllowThreads(__tstate);
14429 if (PyErr_Occurred()) SWIG_fail;
14430 }
14431 {
14432 wxBitmap * resultptr;
14433 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
14434 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14435 }
14436 return resultobj;
14437 fail:
14438 return NULL;
14439 }
14440
14441
14442 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14443 PyObject *resultobj = NULL;
14444 wxImage *arg1 = (wxImage *) 0 ;
14445 byte arg2 ;
14446 byte arg3 ;
14447 byte arg4 ;
14448 wxBitmap result;
14449 PyObject * obj0 = 0 ;
14450 PyObject * obj1 = 0 ;
14451 PyObject * obj2 = 0 ;
14452 PyObject * obj3 = 0 ;
14453 char *kwnames[] = {
14454 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
14455 };
14456
14457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14459 if (SWIG_arg_fail(1)) SWIG_fail;
14460 {
14461 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
14462 if (SWIG_arg_fail(2)) SWIG_fail;
14463 }
14464 {
14465 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
14466 if (SWIG_arg_fail(3)) SWIG_fail;
14467 }
14468 {
14469 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
14470 if (SWIG_arg_fail(4)) SWIG_fail;
14471 }
14472 {
14473 if (!wxPyCheckForApp()) SWIG_fail;
14474 PyThreadState* __tstate = wxPyBeginAllowThreads();
14475 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
14476
14477 wxPyEndAllowThreads(__tstate);
14478 if (PyErr_Occurred()) SWIG_fail;
14479 }
14480 {
14481 wxBitmap * resultptr;
14482 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
14483 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14484 }
14485 return resultobj;
14486 fail:
14487 return NULL;
14488 }
14489
14490
14491 static PyObject *_wrap_Image_RotateHue(PyObject *, PyObject *args, PyObject *kwargs) {
14492 PyObject *resultobj = NULL;
14493 wxImage *arg1 = (wxImage *) 0 ;
14494 double arg2 ;
14495 PyObject * obj0 = 0 ;
14496 PyObject * obj1 = 0 ;
14497 char *kwnames[] = {
14498 (char *) "self",(char *) "angle", NULL
14499 };
14500
14501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) goto fail;
14502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14503 if (SWIG_arg_fail(1)) SWIG_fail;
14504 {
14505 arg2 = static_cast<double >(SWIG_As_double(obj1));
14506 if (SWIG_arg_fail(2)) SWIG_fail;
14507 }
14508 {
14509 PyThreadState* __tstate = wxPyBeginAllowThreads();
14510 (arg1)->RotateHue(arg2);
14511
14512 wxPyEndAllowThreads(__tstate);
14513 if (PyErr_Occurred()) SWIG_fail;
14514 }
14515 Py_INCREF(Py_None); resultobj = Py_None;
14516 return resultobj;
14517 fail:
14518 return NULL;
14519 }
14520
14521
14522 static PyObject *_wrap_Image_RGBtoHSV(PyObject *, PyObject *args, PyObject *kwargs) {
14523 PyObject *resultobj = NULL;
14524 wxImage_RGBValue arg1 ;
14525 wxImage_HSVValue result;
14526 PyObject * obj0 = 0 ;
14527 char *kwnames[] = {
14528 (char *) "rgb", NULL
14529 };
14530
14531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) goto fail;
14532 {
14533 wxImage_RGBValue * argp;
14534 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION);
14535 if (SWIG_arg_fail(1)) SWIG_fail;
14536 if (argp == NULL) {
14537 SWIG_null_ref("wxImage_RGBValue");
14538 }
14539 if (SWIG_arg_fail(1)) SWIG_fail;
14540 arg1 = *argp;
14541 }
14542 {
14543 PyThreadState* __tstate = wxPyBeginAllowThreads();
14544 result = wxImage::RGBtoHSV(arg1);
14545
14546 wxPyEndAllowThreads(__tstate);
14547 if (PyErr_Occurred()) SWIG_fail;
14548 }
14549 {
14550 wxImage_HSVValue * resultptr;
14551 resultptr = new wxImage_HSVValue(static_cast<wxImage_HSVValue & >(result));
14552 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_HSVValue, 1);
14553 }
14554 return resultobj;
14555 fail:
14556 return NULL;
14557 }
14558
14559
14560 static PyObject *_wrap_Image_HSVtoRGB(PyObject *, PyObject *args, PyObject *kwargs) {
14561 PyObject *resultobj = NULL;
14562 wxImage_HSVValue arg1 ;
14563 wxImage_RGBValue result;
14564 PyObject * obj0 = 0 ;
14565 char *kwnames[] = {
14566 (char *) "hsv", NULL
14567 };
14568
14569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) goto fail;
14570 {
14571 wxImage_HSVValue * argp;
14572 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION);
14573 if (SWIG_arg_fail(1)) SWIG_fail;
14574 if (argp == NULL) {
14575 SWIG_null_ref("wxImage_HSVValue");
14576 }
14577 if (SWIG_arg_fail(1)) SWIG_fail;
14578 arg1 = *argp;
14579 }
14580 {
14581 PyThreadState* __tstate = wxPyBeginAllowThreads();
14582 result = wxImage::HSVtoRGB(arg1);
14583
14584 wxPyEndAllowThreads(__tstate);
14585 if (PyErr_Occurred()) SWIG_fail;
14586 }
14587 {
14588 wxImage_RGBValue * resultptr;
14589 resultptr = new wxImage_RGBValue(static_cast<wxImage_RGBValue & >(result));
14590 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_RGBValue, 1);
14591 }
14592 return resultobj;
14593 fail:
14594 return NULL;
14595 }
14596
14597
14598 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
14599 PyObject *obj;
14600 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14601 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
14602 Py_INCREF(obj);
14603 return Py_BuildValue((char *)"");
14604 }
14605 static int _wrap_NullImage_set(PyObject *) {
14606 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
14607 return 1;
14608 }
14609
14610
14611 static PyObject *_wrap_NullImage_get(void) {
14612 PyObject *pyobj = NULL;
14613
14614 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
14615 return pyobj;
14616 }
14617
14618
14619 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
14620 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
14621 return 1;
14622 }
14623
14624
14625 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
14626 PyObject *pyobj = NULL;
14627
14628 {
14629 #if wxUSE_UNICODE
14630 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14631 #else
14632 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14633 #endif
14634 }
14635 return pyobj;
14636 }
14637
14638
14639 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
14640 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
14641 return 1;
14642 }
14643
14644
14645 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
14646 PyObject *pyobj = NULL;
14647
14648 {
14649 #if wxUSE_UNICODE
14650 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14651 #else
14652 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14653 #endif
14654 }
14655 return pyobj;
14656 }
14657
14658
14659 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
14660 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
14661 return 1;
14662 }
14663
14664
14665 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
14666 PyObject *pyobj = NULL;
14667
14668 {
14669 #if wxUSE_UNICODE
14670 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14671 #else
14672 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14673 #endif
14674 }
14675 return pyobj;
14676 }
14677
14678
14679 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
14680 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
14681 return 1;
14682 }
14683
14684
14685 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
14686 PyObject *pyobj = NULL;
14687
14688 {
14689 #if wxUSE_UNICODE
14690 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14691 #else
14692 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14693 #endif
14694 }
14695 return pyobj;
14696 }
14697
14698
14699 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
14700 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
14701 return 1;
14702 }
14703
14704
14705 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
14706 PyObject *pyobj = NULL;
14707
14708 {
14709 #if wxUSE_UNICODE
14710 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14711 #else
14712 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14713 #endif
14714 }
14715 return pyobj;
14716 }
14717
14718
14719 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
14720 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
14721 return 1;
14722 }
14723
14724
14725 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
14726 PyObject *pyobj = NULL;
14727
14728 {
14729 #if wxUSE_UNICODE
14730 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14731 #else
14732 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14733 #endif
14734 }
14735 return pyobj;
14736 }
14737
14738
14739 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
14740 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
14741 return 1;
14742 }
14743
14744
14745 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
14746 PyObject *pyobj = NULL;
14747
14748 {
14749 #if wxUSE_UNICODE
14750 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14751 #else
14752 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14753 #endif
14754 }
14755 return pyobj;
14756 }
14757
14758
14759 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
14760 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
14761 return 1;
14762 }
14763
14764
14765 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
14766 PyObject *pyobj = NULL;
14767
14768 {
14769 #if wxUSE_UNICODE
14770 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14771 #else
14772 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14773 #endif
14774 }
14775 return pyobj;
14776 }
14777
14778
14779 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14780 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14781 return 1;
14782 }
14783
14784
14785 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14786 PyObject *pyobj = NULL;
14787
14788 {
14789 #if wxUSE_UNICODE
14790 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14791 #else
14792 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14793 #endif
14794 }
14795 return pyobj;
14796 }
14797
14798
14799 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14800 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14801 return 1;
14802 }
14803
14804
14805 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14806 PyObject *pyobj = NULL;
14807
14808 {
14809 #if wxUSE_UNICODE
14810 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14811 #else
14812 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14813 #endif
14814 }
14815 return pyobj;
14816 }
14817
14818
14819 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14820 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14821 return 1;
14822 }
14823
14824
14825 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14826 PyObject *pyobj = NULL;
14827
14828 {
14829 #if wxUSE_UNICODE
14830 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14831 #else
14832 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14833 #endif
14834 }
14835 return pyobj;
14836 }
14837
14838
14839 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14840 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14841 return 1;
14842 }
14843
14844
14845 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14846 PyObject *pyobj = NULL;
14847
14848 {
14849 #if wxUSE_UNICODE
14850 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14851 #else
14852 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14853 #endif
14854 }
14855 return pyobj;
14856 }
14857
14858
14859 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14860 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14861 return 1;
14862 }
14863
14864
14865 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14866 PyObject *pyobj = NULL;
14867
14868 {
14869 #if wxUSE_UNICODE
14870 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14871 #else
14872 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14873 #endif
14874 }
14875 return pyobj;
14876 }
14877
14878
14879 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14880 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14881 return 1;
14882 }
14883
14884
14885 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14886 PyObject *pyobj = NULL;
14887
14888 {
14889 #if wxUSE_UNICODE
14890 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14891 #else
14892 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14893 #endif
14894 }
14895 return pyobj;
14896 }
14897
14898
14899 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14900 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14901 return 1;
14902 }
14903
14904
14905 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14906 PyObject *pyobj = NULL;
14907
14908 {
14909 #if wxUSE_UNICODE
14910 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14911 #else
14912 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14913 #endif
14914 }
14915 return pyobj;
14916 }
14917
14918
14919 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14920 PyObject *resultobj = NULL;
14921 wxBMPHandler *result;
14922 char *kwnames[] = {
14923 NULL
14924 };
14925
14926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14927 {
14928 PyThreadState* __tstate = wxPyBeginAllowThreads();
14929 result = (wxBMPHandler *)new wxBMPHandler();
14930
14931 wxPyEndAllowThreads(__tstate);
14932 if (PyErr_Occurred()) SWIG_fail;
14933 }
14934 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14935 return resultobj;
14936 fail:
14937 return NULL;
14938 }
14939
14940
14941 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14942 PyObject *obj;
14943 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14944 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14945 Py_INCREF(obj);
14946 return Py_BuildValue((char *)"");
14947 }
14948 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14949 PyObject *resultobj = NULL;
14950 wxICOHandler *result;
14951 char *kwnames[] = {
14952 NULL
14953 };
14954
14955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14956 {
14957 PyThreadState* __tstate = wxPyBeginAllowThreads();
14958 result = (wxICOHandler *)new wxICOHandler();
14959
14960 wxPyEndAllowThreads(__tstate);
14961 if (PyErr_Occurred()) SWIG_fail;
14962 }
14963 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14964 return resultobj;
14965 fail:
14966 return NULL;
14967 }
14968
14969
14970 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14971 PyObject *obj;
14972 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14973 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14974 Py_INCREF(obj);
14975 return Py_BuildValue((char *)"");
14976 }
14977 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14978 PyObject *resultobj = NULL;
14979 wxCURHandler *result;
14980 char *kwnames[] = {
14981 NULL
14982 };
14983
14984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14985 {
14986 PyThreadState* __tstate = wxPyBeginAllowThreads();
14987 result = (wxCURHandler *)new wxCURHandler();
14988
14989 wxPyEndAllowThreads(__tstate);
14990 if (PyErr_Occurred()) SWIG_fail;
14991 }
14992 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14993 return resultobj;
14994 fail:
14995 return NULL;
14996 }
14997
14998
14999 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
15000 PyObject *obj;
15001 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15002 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
15003 Py_INCREF(obj);
15004 return Py_BuildValue((char *)"");
15005 }
15006 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15007 PyObject *resultobj = NULL;
15008 wxANIHandler *result;
15009 char *kwnames[] = {
15010 NULL
15011 };
15012
15013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
15014 {
15015 PyThreadState* __tstate = wxPyBeginAllowThreads();
15016 result = (wxANIHandler *)new wxANIHandler();
15017
15018 wxPyEndAllowThreads(__tstate);
15019 if (PyErr_Occurred()) SWIG_fail;
15020 }
15021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
15022 return resultobj;
15023 fail:
15024 return NULL;
15025 }
15026
15027
15028 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
15029 PyObject *obj;
15030 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15031 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
15032 Py_INCREF(obj);
15033 return Py_BuildValue((char *)"");
15034 }
15035 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15036 PyObject *resultobj = NULL;
15037 wxPNGHandler *result;
15038 char *kwnames[] = {
15039 NULL
15040 };
15041
15042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
15043 {
15044 PyThreadState* __tstate = wxPyBeginAllowThreads();
15045 result = (wxPNGHandler *)new wxPNGHandler();
15046
15047 wxPyEndAllowThreads(__tstate);
15048 if (PyErr_Occurred()) SWIG_fail;
15049 }
15050 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
15051 return resultobj;
15052 fail:
15053 return NULL;
15054 }
15055
15056
15057 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
15058 PyObject *obj;
15059 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15060 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
15061 Py_INCREF(obj);
15062 return Py_BuildValue((char *)"");
15063 }
15064 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15065 PyObject *resultobj = NULL;
15066 wxGIFHandler *result;
15067 char *kwnames[] = {
15068 NULL
15069 };
15070
15071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
15072 {
15073 PyThreadState* __tstate = wxPyBeginAllowThreads();
15074 result = (wxGIFHandler *)new wxGIFHandler();
15075
15076 wxPyEndAllowThreads(__tstate);
15077 if (PyErr_Occurred()) SWIG_fail;
15078 }
15079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
15080 return resultobj;
15081 fail:
15082 return NULL;
15083 }
15084
15085
15086 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
15087 PyObject *obj;
15088 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15089 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
15090 Py_INCREF(obj);
15091 return Py_BuildValue((char *)"");
15092 }
15093 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15094 PyObject *resultobj = NULL;
15095 wxPCXHandler *result;
15096 char *kwnames[] = {
15097 NULL
15098 };
15099
15100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
15101 {
15102 PyThreadState* __tstate = wxPyBeginAllowThreads();
15103 result = (wxPCXHandler *)new wxPCXHandler();
15104
15105 wxPyEndAllowThreads(__tstate);
15106 if (PyErr_Occurred()) SWIG_fail;
15107 }
15108 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
15109 return resultobj;
15110 fail:
15111 return NULL;
15112 }
15113
15114
15115 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
15116 PyObject *obj;
15117 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15118 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
15119 Py_INCREF(obj);
15120 return Py_BuildValue((char *)"");
15121 }
15122 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15123 PyObject *resultobj = NULL;
15124 wxJPEGHandler *result;
15125 char *kwnames[] = {
15126 NULL
15127 };
15128
15129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
15130 {
15131 PyThreadState* __tstate = wxPyBeginAllowThreads();
15132 result = (wxJPEGHandler *)new wxJPEGHandler();
15133
15134 wxPyEndAllowThreads(__tstate);
15135 if (PyErr_Occurred()) SWIG_fail;
15136 }
15137 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
15138 return resultobj;
15139 fail:
15140 return NULL;
15141 }
15142
15143
15144 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
15145 PyObject *obj;
15146 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15147 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
15148 Py_INCREF(obj);
15149 return Py_BuildValue((char *)"");
15150 }
15151 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15152 PyObject *resultobj = NULL;
15153 wxPNMHandler *result;
15154 char *kwnames[] = {
15155 NULL
15156 };
15157
15158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
15159 {
15160 PyThreadState* __tstate = wxPyBeginAllowThreads();
15161 result = (wxPNMHandler *)new wxPNMHandler();
15162
15163 wxPyEndAllowThreads(__tstate);
15164 if (PyErr_Occurred()) SWIG_fail;
15165 }
15166 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
15167 return resultobj;
15168 fail:
15169 return NULL;
15170 }
15171
15172
15173 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
15174 PyObject *obj;
15175 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15176 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
15177 Py_INCREF(obj);
15178 return Py_BuildValue((char *)"");
15179 }
15180 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15181 PyObject *resultobj = NULL;
15182 wxXPMHandler *result;
15183 char *kwnames[] = {
15184 NULL
15185 };
15186
15187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
15188 {
15189 PyThreadState* __tstate = wxPyBeginAllowThreads();
15190 result = (wxXPMHandler *)new wxXPMHandler();
15191
15192 wxPyEndAllowThreads(__tstate);
15193 if (PyErr_Occurred()) SWIG_fail;
15194 }
15195 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
15196 return resultobj;
15197 fail:
15198 return NULL;
15199 }
15200
15201
15202 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
15203 PyObject *obj;
15204 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15205 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
15206 Py_INCREF(obj);
15207 return Py_BuildValue((char *)"");
15208 }
15209 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15210 PyObject *resultobj = NULL;
15211 wxTIFFHandler *result;
15212 char *kwnames[] = {
15213 NULL
15214 };
15215
15216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
15217 {
15218 PyThreadState* __tstate = wxPyBeginAllowThreads();
15219 result = (wxTIFFHandler *)new wxTIFFHandler();
15220
15221 wxPyEndAllowThreads(__tstate);
15222 if (PyErr_Occurred()) SWIG_fail;
15223 }
15224 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
15225 return resultobj;
15226 fail:
15227 return NULL;
15228 }
15229
15230
15231 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
15232 PyObject *obj;
15233 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15234 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
15235 Py_INCREF(obj);
15236 return Py_BuildValue((char *)"");
15237 }
15238 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
15239 PyObject *resultobj = NULL;
15240 wxImage *arg1 = 0 ;
15241 wxImage *arg2 = 0 ;
15242 int arg3 = (int) 236 ;
15243 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
15244 bool result;
15245 PyObject * obj0 = 0 ;
15246 PyObject * obj1 = 0 ;
15247 PyObject * obj2 = 0 ;
15248 PyObject * obj3 = 0 ;
15249 char *kwnames[] = {
15250 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
15251 };
15252
15253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15254 {
15255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15256 if (SWIG_arg_fail(1)) SWIG_fail;
15257 if (arg1 == NULL) {
15258 SWIG_null_ref("wxImage");
15259 }
15260 if (SWIG_arg_fail(1)) SWIG_fail;
15261 }
15262 {
15263 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15264 if (SWIG_arg_fail(2)) SWIG_fail;
15265 if (arg2 == NULL) {
15266 SWIG_null_ref("wxImage");
15267 }
15268 if (SWIG_arg_fail(2)) SWIG_fail;
15269 }
15270 if (obj2) {
15271 {
15272 arg3 = static_cast<int >(SWIG_As_int(obj2));
15273 if (SWIG_arg_fail(3)) SWIG_fail;
15274 }
15275 }
15276 if (obj3) {
15277 {
15278 arg4 = static_cast<int >(SWIG_As_int(obj3));
15279 if (SWIG_arg_fail(4)) SWIG_fail;
15280 }
15281 }
15282 {
15283 PyThreadState* __tstate = wxPyBeginAllowThreads();
15284 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
15285
15286 wxPyEndAllowThreads(__tstate);
15287 if (PyErr_Occurred()) SWIG_fail;
15288 }
15289 {
15290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15291 }
15292 return resultobj;
15293 fail:
15294 return NULL;
15295 }
15296
15297
15298 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
15299 PyObject *obj;
15300 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15301 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
15302 Py_INCREF(obj);
15303 return Py_BuildValue((char *)"");
15304 }
15305 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15306 PyObject *resultobj = NULL;
15307 wxEvtHandler *result;
15308 char *kwnames[] = {
15309 NULL
15310 };
15311
15312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
15313 {
15314 PyThreadState* __tstate = wxPyBeginAllowThreads();
15315 result = (wxEvtHandler *)new wxEvtHandler();
15316
15317 wxPyEndAllowThreads(__tstate);
15318 if (PyErr_Occurred()) SWIG_fail;
15319 }
15320 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
15321 return resultobj;
15322 fail:
15323 return NULL;
15324 }
15325
15326
15327 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15328 PyObject *resultobj = NULL;
15329 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15330 wxEvtHandler *result;
15331 PyObject * obj0 = 0 ;
15332 char *kwnames[] = {
15333 (char *) "self", NULL
15334 };
15335
15336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
15337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15338 if (SWIG_arg_fail(1)) SWIG_fail;
15339 {
15340 PyThreadState* __tstate = wxPyBeginAllowThreads();
15341 result = (wxEvtHandler *)(arg1)->GetNextHandler();
15342
15343 wxPyEndAllowThreads(__tstate);
15344 if (PyErr_Occurred()) SWIG_fail;
15345 }
15346 {
15347 resultobj = wxPyMake_wxObject(result, 0);
15348 }
15349 return resultobj;
15350 fail:
15351 return NULL;
15352 }
15353
15354
15355 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15356 PyObject *resultobj = NULL;
15357 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15358 wxEvtHandler *result;
15359 PyObject * obj0 = 0 ;
15360 char *kwnames[] = {
15361 (char *) "self", NULL
15362 };
15363
15364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
15365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15366 if (SWIG_arg_fail(1)) SWIG_fail;
15367 {
15368 PyThreadState* __tstate = wxPyBeginAllowThreads();
15369 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
15370
15371 wxPyEndAllowThreads(__tstate);
15372 if (PyErr_Occurred()) SWIG_fail;
15373 }
15374 {
15375 resultobj = wxPyMake_wxObject(result, 0);
15376 }
15377 return resultobj;
15378 fail:
15379 return NULL;
15380 }
15381
15382
15383 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15384 PyObject *resultobj = NULL;
15385 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15386 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15387 PyObject * obj0 = 0 ;
15388 PyObject * obj1 = 0 ;
15389 char *kwnames[] = {
15390 (char *) "self",(char *) "handler", NULL
15391 };
15392
15393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
15394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15395 if (SWIG_arg_fail(1)) SWIG_fail;
15396 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15397 if (SWIG_arg_fail(2)) SWIG_fail;
15398 {
15399 PyThreadState* __tstate = wxPyBeginAllowThreads();
15400 (arg1)->SetNextHandler(arg2);
15401
15402 wxPyEndAllowThreads(__tstate);
15403 if (PyErr_Occurred()) SWIG_fail;
15404 }
15405 Py_INCREF(Py_None); resultobj = Py_None;
15406 return resultobj;
15407 fail:
15408 return NULL;
15409 }
15410
15411
15412 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15413 PyObject *resultobj = NULL;
15414 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15415 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15416 PyObject * obj0 = 0 ;
15417 PyObject * obj1 = 0 ;
15418 char *kwnames[] = {
15419 (char *) "self",(char *) "handler", NULL
15420 };
15421
15422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
15423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15424 if (SWIG_arg_fail(1)) SWIG_fail;
15425 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15426 if (SWIG_arg_fail(2)) SWIG_fail;
15427 {
15428 PyThreadState* __tstate = wxPyBeginAllowThreads();
15429 (arg1)->SetPreviousHandler(arg2);
15430
15431 wxPyEndAllowThreads(__tstate);
15432 if (PyErr_Occurred()) SWIG_fail;
15433 }
15434 Py_INCREF(Py_None); resultobj = Py_None;
15435 return resultobj;
15436 fail:
15437 return NULL;
15438 }
15439
15440
15441 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15442 PyObject *resultobj = NULL;
15443 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15444 bool result;
15445 PyObject * obj0 = 0 ;
15446 char *kwnames[] = {
15447 (char *) "self", NULL
15448 };
15449
15450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
15451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15452 if (SWIG_arg_fail(1)) SWIG_fail;
15453 {
15454 PyThreadState* __tstate = wxPyBeginAllowThreads();
15455 result = (bool)(arg1)->GetEvtHandlerEnabled();
15456
15457 wxPyEndAllowThreads(__tstate);
15458 if (PyErr_Occurred()) SWIG_fail;
15459 }
15460 {
15461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15462 }
15463 return resultobj;
15464 fail:
15465 return NULL;
15466 }
15467
15468
15469 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15470 PyObject *resultobj = NULL;
15471 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15472 bool arg2 ;
15473 PyObject * obj0 = 0 ;
15474 PyObject * obj1 = 0 ;
15475 char *kwnames[] = {
15476 (char *) "self",(char *) "enabled", NULL
15477 };
15478
15479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
15480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15481 if (SWIG_arg_fail(1)) SWIG_fail;
15482 {
15483 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
15484 if (SWIG_arg_fail(2)) SWIG_fail;
15485 }
15486 {
15487 PyThreadState* __tstate = wxPyBeginAllowThreads();
15488 (arg1)->SetEvtHandlerEnabled(arg2);
15489
15490 wxPyEndAllowThreads(__tstate);
15491 if (PyErr_Occurred()) SWIG_fail;
15492 }
15493 Py_INCREF(Py_None); resultobj = Py_None;
15494 return resultobj;
15495 fail:
15496 return NULL;
15497 }
15498
15499
15500 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15501 PyObject *resultobj = NULL;
15502 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15503 wxEvent *arg2 = 0 ;
15504 bool result;
15505 PyObject * obj0 = 0 ;
15506 PyObject * obj1 = 0 ;
15507 char *kwnames[] = {
15508 (char *) "self",(char *) "event", NULL
15509 };
15510
15511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
15512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15513 if (SWIG_arg_fail(1)) SWIG_fail;
15514 {
15515 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15516 if (SWIG_arg_fail(2)) SWIG_fail;
15517 if (arg2 == NULL) {
15518 SWIG_null_ref("wxEvent");
15519 }
15520 if (SWIG_arg_fail(2)) SWIG_fail;
15521 }
15522 {
15523 PyThreadState* __tstate = wxPyBeginAllowThreads();
15524 result = (bool)(arg1)->ProcessEvent(*arg2);
15525
15526 wxPyEndAllowThreads(__tstate);
15527 if (PyErr_Occurred()) SWIG_fail;
15528 }
15529 {
15530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15531 }
15532 return resultobj;
15533 fail:
15534 return NULL;
15535 }
15536
15537
15538 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15539 PyObject *resultobj = NULL;
15540 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15541 wxEvent *arg2 = 0 ;
15542 PyObject * obj0 = 0 ;
15543 PyObject * obj1 = 0 ;
15544 char *kwnames[] = {
15545 (char *) "self",(char *) "event", NULL
15546 };
15547
15548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
15549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15550 if (SWIG_arg_fail(1)) SWIG_fail;
15551 {
15552 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15553 if (SWIG_arg_fail(2)) SWIG_fail;
15554 if (arg2 == NULL) {
15555 SWIG_null_ref("wxEvent");
15556 }
15557 if (SWIG_arg_fail(2)) SWIG_fail;
15558 }
15559 {
15560 PyThreadState* __tstate = wxPyBeginAllowThreads();
15561 (arg1)->AddPendingEvent(*arg2);
15562
15563 wxPyEndAllowThreads(__tstate);
15564 if (PyErr_Occurred()) SWIG_fail;
15565 }
15566 Py_INCREF(Py_None); resultobj = Py_None;
15567 return resultobj;
15568 fail:
15569 return NULL;
15570 }
15571
15572
15573 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
15574 PyObject *resultobj = NULL;
15575 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15576 PyObject * obj0 = 0 ;
15577 char *kwnames[] = {
15578 (char *) "self", NULL
15579 };
15580
15581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
15582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15583 if (SWIG_arg_fail(1)) SWIG_fail;
15584 {
15585 PyThreadState* __tstate = wxPyBeginAllowThreads();
15586 (arg1)->ProcessPendingEvents();
15587
15588 wxPyEndAllowThreads(__tstate);
15589 if (PyErr_Occurred()) SWIG_fail;
15590 }
15591 Py_INCREF(Py_None); resultobj = Py_None;
15592 return resultobj;
15593 fail:
15594 return NULL;
15595 }
15596
15597
15598 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
15599 PyObject *resultobj = NULL;
15600 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15601 int arg2 ;
15602 int arg3 ;
15603 int arg4 ;
15604 PyObject *arg5 = (PyObject *) 0 ;
15605 PyObject * obj0 = 0 ;
15606 PyObject * obj1 = 0 ;
15607 PyObject * obj2 = 0 ;
15608 PyObject * obj3 = 0 ;
15609 PyObject * obj4 = 0 ;
15610 char *kwnames[] = {
15611 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
15612 };
15613
15614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15616 if (SWIG_arg_fail(1)) SWIG_fail;
15617 {
15618 arg2 = static_cast<int >(SWIG_As_int(obj1));
15619 if (SWIG_arg_fail(2)) SWIG_fail;
15620 }
15621 {
15622 arg3 = static_cast<int >(SWIG_As_int(obj2));
15623 if (SWIG_arg_fail(3)) SWIG_fail;
15624 }
15625 {
15626 arg4 = static_cast<int >(SWIG_As_int(obj3));
15627 if (SWIG_arg_fail(4)) SWIG_fail;
15628 }
15629 arg5 = obj4;
15630 {
15631 PyThreadState* __tstate = wxPyBeginAllowThreads();
15632 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
15633
15634 wxPyEndAllowThreads(__tstate);
15635 if (PyErr_Occurred()) SWIG_fail;
15636 }
15637 Py_INCREF(Py_None); resultobj = Py_None;
15638 return resultobj;
15639 fail:
15640 return NULL;
15641 }
15642
15643
15644 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
15645 PyObject *resultobj = NULL;
15646 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15647 int arg2 ;
15648 int arg3 = (int) -1 ;
15649 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
15650 bool result;
15651 PyObject * obj0 = 0 ;
15652 PyObject * obj1 = 0 ;
15653 PyObject * obj2 = 0 ;
15654 PyObject * obj3 = 0 ;
15655 char *kwnames[] = {
15656 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
15657 };
15658
15659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15661 if (SWIG_arg_fail(1)) SWIG_fail;
15662 {
15663 arg2 = static_cast<int >(SWIG_As_int(obj1));
15664 if (SWIG_arg_fail(2)) SWIG_fail;
15665 }
15666 if (obj2) {
15667 {
15668 arg3 = static_cast<int >(SWIG_As_int(obj2));
15669 if (SWIG_arg_fail(3)) SWIG_fail;
15670 }
15671 }
15672 if (obj3) {
15673 {
15674 arg4 = static_cast<wxEventType >(SWIG_As_int(obj3));
15675 if (SWIG_arg_fail(4)) SWIG_fail;
15676 }
15677 }
15678 {
15679 PyThreadState* __tstate = wxPyBeginAllowThreads();
15680 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
15681
15682 wxPyEndAllowThreads(__tstate);
15683 if (PyErr_Occurred()) SWIG_fail;
15684 }
15685 {
15686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15687 }
15688 return resultobj;
15689 fail:
15690 return NULL;
15691 }
15692
15693
15694 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
15695 PyObject *resultobj = NULL;
15696 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15697 PyObject *arg2 = (PyObject *) 0 ;
15698 bool arg3 = (bool) true ;
15699 PyObject * obj0 = 0 ;
15700 PyObject * obj1 = 0 ;
15701 PyObject * obj2 = 0 ;
15702 char *kwnames[] = {
15703 (char *) "self",(char *) "_self",(char *) "incref", NULL
15704 };
15705
15706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
15707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15708 if (SWIG_arg_fail(1)) SWIG_fail;
15709 arg2 = obj1;
15710 if (obj2) {
15711 {
15712 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
15713 if (SWIG_arg_fail(3)) SWIG_fail;
15714 }
15715 }
15716 {
15717 PyThreadState* __tstate = wxPyBeginAllowThreads();
15718 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
15719
15720 wxPyEndAllowThreads(__tstate);
15721 if (PyErr_Occurred()) SWIG_fail;
15722 }
15723 Py_INCREF(Py_None); resultobj = Py_None;
15724 return resultobj;
15725 fail:
15726 return NULL;
15727 }
15728
15729
15730 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
15731 PyObject *obj;
15732 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15733 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
15734 Py_INCREF(obj);
15735 return Py_BuildValue((char *)"");
15736 }
15737 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15738 PyObject *resultobj = NULL;
15739 wxEventType result;
15740 char *kwnames[] = {
15741 NULL
15742 };
15743
15744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
15745 {
15746 PyThreadState* __tstate = wxPyBeginAllowThreads();
15747 result = (wxEventType)wxNewEventType();
15748
15749 wxPyEndAllowThreads(__tstate);
15750 if (PyErr_Occurred()) SWIG_fail;
15751 }
15752 {
15753 resultobj = SWIG_From_int(static_cast<int >(result));
15754 }
15755 return resultobj;
15756 fail:
15757 return NULL;
15758 }
15759
15760
15761 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
15762 PyObject *resultobj = NULL;
15763 wxEvent *arg1 = (wxEvent *) 0 ;
15764 PyObject * obj0 = 0 ;
15765 char *kwnames[] = {
15766 (char *) "self", NULL
15767 };
15768
15769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
15770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15771 if (SWIG_arg_fail(1)) SWIG_fail;
15772 {
15773 PyThreadState* __tstate = wxPyBeginAllowThreads();
15774 delete arg1;
15775
15776 wxPyEndAllowThreads(__tstate);
15777 if (PyErr_Occurred()) SWIG_fail;
15778 }
15779 Py_INCREF(Py_None); resultobj = Py_None;
15780 return resultobj;
15781 fail:
15782 return NULL;
15783 }
15784
15785
15786 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15787 PyObject *resultobj = NULL;
15788 wxEvent *arg1 = (wxEvent *) 0 ;
15789 wxEventType arg2 ;
15790 PyObject * obj0 = 0 ;
15791 PyObject * obj1 = 0 ;
15792 char *kwnames[] = {
15793 (char *) "self",(char *) "typ", NULL
15794 };
15795
15796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15798 if (SWIG_arg_fail(1)) SWIG_fail;
15799 {
15800 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
15801 if (SWIG_arg_fail(2)) SWIG_fail;
15802 }
15803 {
15804 PyThreadState* __tstate = wxPyBeginAllowThreads();
15805 (arg1)->SetEventType(arg2);
15806
15807 wxPyEndAllowThreads(__tstate);
15808 if (PyErr_Occurred()) SWIG_fail;
15809 }
15810 Py_INCREF(Py_None); resultobj = Py_None;
15811 return resultobj;
15812 fail:
15813 return NULL;
15814 }
15815
15816
15817 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15818 PyObject *resultobj = NULL;
15819 wxEvent *arg1 = (wxEvent *) 0 ;
15820 wxEventType result;
15821 PyObject * obj0 = 0 ;
15822 char *kwnames[] = {
15823 (char *) "self", NULL
15824 };
15825
15826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15828 if (SWIG_arg_fail(1)) SWIG_fail;
15829 {
15830 PyThreadState* __tstate = wxPyBeginAllowThreads();
15831 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15832
15833 wxPyEndAllowThreads(__tstate);
15834 if (PyErr_Occurred()) SWIG_fail;
15835 }
15836 {
15837 resultobj = SWIG_From_int(static_cast<int >(result));
15838 }
15839 return resultobj;
15840 fail:
15841 return NULL;
15842 }
15843
15844
15845 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15846 PyObject *resultobj = NULL;
15847 wxEvent *arg1 = (wxEvent *) 0 ;
15848 wxObject *result;
15849 PyObject * obj0 = 0 ;
15850 char *kwnames[] = {
15851 (char *) "self", NULL
15852 };
15853
15854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15856 if (SWIG_arg_fail(1)) SWIG_fail;
15857 {
15858 PyThreadState* __tstate = wxPyBeginAllowThreads();
15859 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15860
15861 wxPyEndAllowThreads(__tstate);
15862 if (PyErr_Occurred()) SWIG_fail;
15863 }
15864 {
15865 resultobj = wxPyMake_wxObject(result, (bool)0);
15866 }
15867 return resultobj;
15868 fail:
15869 return NULL;
15870 }
15871
15872
15873 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15874 PyObject *resultobj = NULL;
15875 wxEvent *arg1 = (wxEvent *) 0 ;
15876 wxObject *arg2 = (wxObject *) 0 ;
15877 PyObject * obj0 = 0 ;
15878 PyObject * obj1 = 0 ;
15879 char *kwnames[] = {
15880 (char *) "self",(char *) "obj", NULL
15881 };
15882
15883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15885 if (SWIG_arg_fail(1)) SWIG_fail;
15886 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15887 if (SWIG_arg_fail(2)) SWIG_fail;
15888 {
15889 PyThreadState* __tstate = wxPyBeginAllowThreads();
15890 (arg1)->SetEventObject(arg2);
15891
15892 wxPyEndAllowThreads(__tstate);
15893 if (PyErr_Occurred()) SWIG_fail;
15894 }
15895 Py_INCREF(Py_None); resultobj = Py_None;
15896 return resultobj;
15897 fail:
15898 return NULL;
15899 }
15900
15901
15902 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15903 PyObject *resultobj = NULL;
15904 wxEvent *arg1 = (wxEvent *) 0 ;
15905 long result;
15906 PyObject * obj0 = 0 ;
15907 char *kwnames[] = {
15908 (char *) "self", NULL
15909 };
15910
15911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15913 if (SWIG_arg_fail(1)) SWIG_fail;
15914 {
15915 PyThreadState* __tstate = wxPyBeginAllowThreads();
15916 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15917
15918 wxPyEndAllowThreads(__tstate);
15919 if (PyErr_Occurred()) SWIG_fail;
15920 }
15921 {
15922 resultobj = SWIG_From_long(static_cast<long >(result));
15923 }
15924 return resultobj;
15925 fail:
15926 return NULL;
15927 }
15928
15929
15930 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15931 PyObject *resultobj = NULL;
15932 wxEvent *arg1 = (wxEvent *) 0 ;
15933 long arg2 = (long) 0 ;
15934 PyObject * obj0 = 0 ;
15935 PyObject * obj1 = 0 ;
15936 char *kwnames[] = {
15937 (char *) "self",(char *) "ts", NULL
15938 };
15939
15940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15942 if (SWIG_arg_fail(1)) SWIG_fail;
15943 if (obj1) {
15944 {
15945 arg2 = static_cast<long >(SWIG_As_long(obj1));
15946 if (SWIG_arg_fail(2)) SWIG_fail;
15947 }
15948 }
15949 {
15950 PyThreadState* __tstate = wxPyBeginAllowThreads();
15951 (arg1)->SetTimestamp(arg2);
15952
15953 wxPyEndAllowThreads(__tstate);
15954 if (PyErr_Occurred()) SWIG_fail;
15955 }
15956 Py_INCREF(Py_None); resultobj = Py_None;
15957 return resultobj;
15958 fail:
15959 return NULL;
15960 }
15961
15962
15963 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15964 PyObject *resultobj = NULL;
15965 wxEvent *arg1 = (wxEvent *) 0 ;
15966 int result;
15967 PyObject * obj0 = 0 ;
15968 char *kwnames[] = {
15969 (char *) "self", NULL
15970 };
15971
15972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15974 if (SWIG_arg_fail(1)) SWIG_fail;
15975 {
15976 PyThreadState* __tstate = wxPyBeginAllowThreads();
15977 result = (int)((wxEvent const *)arg1)->GetId();
15978
15979 wxPyEndAllowThreads(__tstate);
15980 if (PyErr_Occurred()) SWIG_fail;
15981 }
15982 {
15983 resultobj = SWIG_From_int(static_cast<int >(result));
15984 }
15985 return resultobj;
15986 fail:
15987 return NULL;
15988 }
15989
15990
15991 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15992 PyObject *resultobj = NULL;
15993 wxEvent *arg1 = (wxEvent *) 0 ;
15994 int arg2 ;
15995 PyObject * obj0 = 0 ;
15996 PyObject * obj1 = 0 ;
15997 char *kwnames[] = {
15998 (char *) "self",(char *) "Id", NULL
15999 };
16000
16001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
16002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16003 if (SWIG_arg_fail(1)) SWIG_fail;
16004 {
16005 arg2 = static_cast<int >(SWIG_As_int(obj1));
16006 if (SWIG_arg_fail(2)) SWIG_fail;
16007 }
16008 {
16009 PyThreadState* __tstate = wxPyBeginAllowThreads();
16010 (arg1)->SetId(arg2);
16011
16012 wxPyEndAllowThreads(__tstate);
16013 if (PyErr_Occurred()) SWIG_fail;
16014 }
16015 Py_INCREF(Py_None); resultobj = Py_None;
16016 return resultobj;
16017 fail:
16018 return NULL;
16019 }
16020
16021
16022 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16023 PyObject *resultobj = NULL;
16024 wxEvent *arg1 = (wxEvent *) 0 ;
16025 bool result;
16026 PyObject * obj0 = 0 ;
16027 char *kwnames[] = {
16028 (char *) "self", NULL
16029 };
16030
16031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
16032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16033 if (SWIG_arg_fail(1)) SWIG_fail;
16034 {
16035 PyThreadState* __tstate = wxPyBeginAllowThreads();
16036 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
16037
16038 wxPyEndAllowThreads(__tstate);
16039 if (PyErr_Occurred()) SWIG_fail;
16040 }
16041 {
16042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16043 }
16044 return resultobj;
16045 fail:
16046 return NULL;
16047 }
16048
16049
16050 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
16051 PyObject *resultobj = NULL;
16052 wxEvent *arg1 = (wxEvent *) 0 ;
16053 bool arg2 = (bool) true ;
16054 PyObject * obj0 = 0 ;
16055 PyObject * obj1 = 0 ;
16056 char *kwnames[] = {
16057 (char *) "self",(char *) "skip", NULL
16058 };
16059
16060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
16061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16062 if (SWIG_arg_fail(1)) SWIG_fail;
16063 if (obj1) {
16064 {
16065 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
16066 if (SWIG_arg_fail(2)) SWIG_fail;
16067 }
16068 }
16069 {
16070 PyThreadState* __tstate = wxPyBeginAllowThreads();
16071 (arg1)->Skip(arg2);
16072
16073 wxPyEndAllowThreads(__tstate);
16074 if (PyErr_Occurred()) SWIG_fail;
16075 }
16076 Py_INCREF(Py_None); resultobj = Py_None;
16077 return resultobj;
16078 fail:
16079 return NULL;
16080 }
16081
16082
16083 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
16084 PyObject *resultobj = NULL;
16085 wxEvent *arg1 = (wxEvent *) 0 ;
16086 bool result;
16087 PyObject * obj0 = 0 ;
16088 char *kwnames[] = {
16089 (char *) "self", NULL
16090 };
16091
16092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
16093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16094 if (SWIG_arg_fail(1)) SWIG_fail;
16095 {
16096 PyThreadState* __tstate = wxPyBeginAllowThreads();
16097 result = (bool)((wxEvent const *)arg1)->GetSkipped();
16098
16099 wxPyEndAllowThreads(__tstate);
16100 if (PyErr_Occurred()) SWIG_fail;
16101 }
16102 {
16103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16104 }
16105 return resultobj;
16106 fail:
16107 return NULL;
16108 }
16109
16110
16111 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
16112 PyObject *resultobj = NULL;
16113 wxEvent *arg1 = (wxEvent *) 0 ;
16114 bool result;
16115 PyObject * obj0 = 0 ;
16116 char *kwnames[] = {
16117 (char *) "self", NULL
16118 };
16119
16120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
16121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16122 if (SWIG_arg_fail(1)) SWIG_fail;
16123 {
16124 PyThreadState* __tstate = wxPyBeginAllowThreads();
16125 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
16126
16127 wxPyEndAllowThreads(__tstate);
16128 if (PyErr_Occurred()) SWIG_fail;
16129 }
16130 {
16131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16132 }
16133 return resultobj;
16134 fail:
16135 return NULL;
16136 }
16137
16138
16139 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
16140 PyObject *resultobj = NULL;
16141 wxEvent *arg1 = (wxEvent *) 0 ;
16142 int result;
16143 PyObject * obj0 = 0 ;
16144 char *kwnames[] = {
16145 (char *) "self", NULL
16146 };
16147
16148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
16149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16150 if (SWIG_arg_fail(1)) SWIG_fail;
16151 {
16152 PyThreadState* __tstate = wxPyBeginAllowThreads();
16153 result = (int)(arg1)->StopPropagation();
16154
16155 wxPyEndAllowThreads(__tstate);
16156 if (PyErr_Occurred()) SWIG_fail;
16157 }
16158 {
16159 resultobj = SWIG_From_int(static_cast<int >(result));
16160 }
16161 return resultobj;
16162 fail:
16163 return NULL;
16164 }
16165
16166
16167 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
16168 PyObject *resultobj = NULL;
16169 wxEvent *arg1 = (wxEvent *) 0 ;
16170 int arg2 ;
16171 PyObject * obj0 = 0 ;
16172 PyObject * obj1 = 0 ;
16173 char *kwnames[] = {
16174 (char *) "self",(char *) "propagationLevel", NULL
16175 };
16176
16177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
16178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16179 if (SWIG_arg_fail(1)) SWIG_fail;
16180 {
16181 arg2 = static_cast<int >(SWIG_As_int(obj1));
16182 if (SWIG_arg_fail(2)) SWIG_fail;
16183 }
16184 {
16185 PyThreadState* __tstate = wxPyBeginAllowThreads();
16186 (arg1)->ResumePropagation(arg2);
16187
16188 wxPyEndAllowThreads(__tstate);
16189 if (PyErr_Occurred()) SWIG_fail;
16190 }
16191 Py_INCREF(Py_None); resultobj = Py_None;
16192 return resultobj;
16193 fail:
16194 return NULL;
16195 }
16196
16197
16198 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16199 PyObject *resultobj = NULL;
16200 wxEvent *arg1 = (wxEvent *) 0 ;
16201 wxEvent *result;
16202 PyObject * obj0 = 0 ;
16203 char *kwnames[] = {
16204 (char *) "self", NULL
16205 };
16206
16207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
16208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16209 if (SWIG_arg_fail(1)) SWIG_fail;
16210 {
16211 PyThreadState* __tstate = wxPyBeginAllowThreads();
16212 result = (wxEvent *)(arg1)->Clone();
16213
16214 wxPyEndAllowThreads(__tstate);
16215 if (PyErr_Occurred()) SWIG_fail;
16216 }
16217 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16218 return resultobj;
16219 fail:
16220 return NULL;
16221 }
16222
16223
16224 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
16225 PyObject *obj;
16226 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16227 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
16228 Py_INCREF(obj);
16229 return Py_BuildValue((char *)"");
16230 }
16231 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16232 PyObject *resultobj = NULL;
16233 wxEvent *arg1 = 0 ;
16234 wxPropagationDisabler *result;
16235 PyObject * obj0 = 0 ;
16236 char *kwnames[] = {
16237 (char *) "event", NULL
16238 };
16239
16240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
16241 {
16242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16243 if (SWIG_arg_fail(1)) SWIG_fail;
16244 if (arg1 == NULL) {
16245 SWIG_null_ref("wxEvent");
16246 }
16247 if (SWIG_arg_fail(1)) SWIG_fail;
16248 }
16249 {
16250 PyThreadState* __tstate = wxPyBeginAllowThreads();
16251 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
16252
16253 wxPyEndAllowThreads(__tstate);
16254 if (PyErr_Occurred()) SWIG_fail;
16255 }
16256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
16257 return resultobj;
16258 fail:
16259 return NULL;
16260 }
16261
16262
16263 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16264 PyObject *resultobj = NULL;
16265 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
16266 PyObject * obj0 = 0 ;
16267 char *kwnames[] = {
16268 (char *) "self", NULL
16269 };
16270
16271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
16272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
16273 if (SWIG_arg_fail(1)) SWIG_fail;
16274 {
16275 PyThreadState* __tstate = wxPyBeginAllowThreads();
16276 delete arg1;
16277
16278 wxPyEndAllowThreads(__tstate);
16279 if (PyErr_Occurred()) SWIG_fail;
16280 }
16281 Py_INCREF(Py_None); resultobj = Py_None;
16282 return resultobj;
16283 fail:
16284 return NULL;
16285 }
16286
16287
16288 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
16289 PyObject *obj;
16290 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16291 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
16292 Py_INCREF(obj);
16293 return Py_BuildValue((char *)"");
16294 }
16295 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16296 PyObject *resultobj = NULL;
16297 wxEvent *arg1 = 0 ;
16298 wxPropagateOnce *result;
16299 PyObject * obj0 = 0 ;
16300 char *kwnames[] = {
16301 (char *) "event", NULL
16302 };
16303
16304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
16305 {
16306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16307 if (SWIG_arg_fail(1)) SWIG_fail;
16308 if (arg1 == NULL) {
16309 SWIG_null_ref("wxEvent");
16310 }
16311 if (SWIG_arg_fail(1)) SWIG_fail;
16312 }
16313 {
16314 PyThreadState* __tstate = wxPyBeginAllowThreads();
16315 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
16316
16317 wxPyEndAllowThreads(__tstate);
16318 if (PyErr_Occurred()) SWIG_fail;
16319 }
16320 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
16321 return resultobj;
16322 fail:
16323 return NULL;
16324 }
16325
16326
16327 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16328 PyObject *resultobj = NULL;
16329 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
16330 PyObject * obj0 = 0 ;
16331 char *kwnames[] = {
16332 (char *) "self", NULL
16333 };
16334
16335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
16336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
16337 if (SWIG_arg_fail(1)) SWIG_fail;
16338 {
16339 PyThreadState* __tstate = wxPyBeginAllowThreads();
16340 delete arg1;
16341
16342 wxPyEndAllowThreads(__tstate);
16343 if (PyErr_Occurred()) SWIG_fail;
16344 }
16345 Py_INCREF(Py_None); resultobj = Py_None;
16346 return resultobj;
16347 fail:
16348 return NULL;
16349 }
16350
16351
16352 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
16353 PyObject *obj;
16354 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16355 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
16356 Py_INCREF(obj);
16357 return Py_BuildValue((char *)"");
16358 }
16359 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16360 PyObject *resultobj = NULL;
16361 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16362 int arg2 = (int) 0 ;
16363 wxCommandEvent *result;
16364 PyObject * obj0 = 0 ;
16365 PyObject * obj1 = 0 ;
16366 char *kwnames[] = {
16367 (char *) "commandType",(char *) "winid", NULL
16368 };
16369
16370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
16371 if (obj0) {
16372 {
16373 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16374 if (SWIG_arg_fail(1)) SWIG_fail;
16375 }
16376 }
16377 if (obj1) {
16378 {
16379 arg2 = static_cast<int >(SWIG_As_int(obj1));
16380 if (SWIG_arg_fail(2)) SWIG_fail;
16381 }
16382 }
16383 {
16384 PyThreadState* __tstate = wxPyBeginAllowThreads();
16385 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
16386
16387 wxPyEndAllowThreads(__tstate);
16388 if (PyErr_Occurred()) SWIG_fail;
16389 }
16390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
16391 return resultobj;
16392 fail:
16393 return NULL;
16394 }
16395
16396
16397 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16398 PyObject *resultobj = NULL;
16399 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16400 int result;
16401 PyObject * obj0 = 0 ;
16402 char *kwnames[] = {
16403 (char *) "self", NULL
16404 };
16405
16406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
16407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16408 if (SWIG_arg_fail(1)) SWIG_fail;
16409 {
16410 PyThreadState* __tstate = wxPyBeginAllowThreads();
16411 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
16412
16413 wxPyEndAllowThreads(__tstate);
16414 if (PyErr_Occurred()) SWIG_fail;
16415 }
16416 {
16417 resultobj = SWIG_From_int(static_cast<int >(result));
16418 }
16419 return resultobj;
16420 fail:
16421 return NULL;
16422 }
16423
16424
16425 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
16426 PyObject *resultobj = NULL;
16427 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16428 wxString *arg2 = 0 ;
16429 bool temp2 = false ;
16430 PyObject * obj0 = 0 ;
16431 PyObject * obj1 = 0 ;
16432 char *kwnames[] = {
16433 (char *) "self",(char *) "s", NULL
16434 };
16435
16436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
16437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16438 if (SWIG_arg_fail(1)) SWIG_fail;
16439 {
16440 arg2 = wxString_in_helper(obj1);
16441 if (arg2 == NULL) SWIG_fail;
16442 temp2 = true;
16443 }
16444 {
16445 PyThreadState* __tstate = wxPyBeginAllowThreads();
16446 (arg1)->SetString((wxString const &)*arg2);
16447
16448 wxPyEndAllowThreads(__tstate);
16449 if (PyErr_Occurred()) SWIG_fail;
16450 }
16451 Py_INCREF(Py_None); resultobj = Py_None;
16452 {
16453 if (temp2)
16454 delete arg2;
16455 }
16456 return resultobj;
16457 fail:
16458 {
16459 if (temp2)
16460 delete arg2;
16461 }
16462 return NULL;
16463 }
16464
16465
16466 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
16467 PyObject *resultobj = NULL;
16468 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16469 wxString result;
16470 PyObject * obj0 = 0 ;
16471 char *kwnames[] = {
16472 (char *) "self", NULL
16473 };
16474
16475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
16476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16477 if (SWIG_arg_fail(1)) SWIG_fail;
16478 {
16479 PyThreadState* __tstate = wxPyBeginAllowThreads();
16480 result = ((wxCommandEvent const *)arg1)->GetString();
16481
16482 wxPyEndAllowThreads(__tstate);
16483 if (PyErr_Occurred()) SWIG_fail;
16484 }
16485 {
16486 #if wxUSE_UNICODE
16487 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16488 #else
16489 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16490 #endif
16491 }
16492 return resultobj;
16493 fail:
16494 return NULL;
16495 }
16496
16497
16498 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
16499 PyObject *resultobj = NULL;
16500 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16501 bool result;
16502 PyObject * obj0 = 0 ;
16503 char *kwnames[] = {
16504 (char *) "self", NULL
16505 };
16506
16507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
16508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16509 if (SWIG_arg_fail(1)) SWIG_fail;
16510 {
16511 PyThreadState* __tstate = wxPyBeginAllowThreads();
16512 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
16513
16514 wxPyEndAllowThreads(__tstate);
16515 if (PyErr_Occurred()) SWIG_fail;
16516 }
16517 {
16518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16519 }
16520 return resultobj;
16521 fail:
16522 return NULL;
16523 }
16524
16525
16526 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16527 PyObject *resultobj = NULL;
16528 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16529 bool result;
16530 PyObject * obj0 = 0 ;
16531 char *kwnames[] = {
16532 (char *) "self", NULL
16533 };
16534
16535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
16536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16537 if (SWIG_arg_fail(1)) SWIG_fail;
16538 {
16539 PyThreadState* __tstate = wxPyBeginAllowThreads();
16540 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
16541
16542 wxPyEndAllowThreads(__tstate);
16543 if (PyErr_Occurred()) SWIG_fail;
16544 }
16545 {
16546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16547 }
16548 return resultobj;
16549 fail:
16550 return NULL;
16551 }
16552
16553
16554 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16555 PyObject *resultobj = NULL;
16556 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16557 long arg2 ;
16558 PyObject * obj0 = 0 ;
16559 PyObject * obj1 = 0 ;
16560 char *kwnames[] = {
16561 (char *) "self",(char *) "extraLong", NULL
16562 };
16563
16564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
16565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16566 if (SWIG_arg_fail(1)) SWIG_fail;
16567 {
16568 arg2 = static_cast<long >(SWIG_As_long(obj1));
16569 if (SWIG_arg_fail(2)) SWIG_fail;
16570 }
16571 {
16572 PyThreadState* __tstate = wxPyBeginAllowThreads();
16573 (arg1)->SetExtraLong(arg2);
16574
16575 wxPyEndAllowThreads(__tstate);
16576 if (PyErr_Occurred()) SWIG_fail;
16577 }
16578 Py_INCREF(Py_None); resultobj = Py_None;
16579 return resultobj;
16580 fail:
16581 return NULL;
16582 }
16583
16584
16585 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16586 PyObject *resultobj = NULL;
16587 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16588 long result;
16589 PyObject * obj0 = 0 ;
16590 char *kwnames[] = {
16591 (char *) "self", NULL
16592 };
16593
16594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
16595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16596 if (SWIG_arg_fail(1)) SWIG_fail;
16597 {
16598 PyThreadState* __tstate = wxPyBeginAllowThreads();
16599 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
16600
16601 wxPyEndAllowThreads(__tstate);
16602 if (PyErr_Occurred()) SWIG_fail;
16603 }
16604 {
16605 resultobj = SWIG_From_long(static_cast<long >(result));
16606 }
16607 return resultobj;
16608 fail:
16609 return NULL;
16610 }
16611
16612
16613 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16614 PyObject *resultobj = NULL;
16615 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16616 int arg2 ;
16617 PyObject * obj0 = 0 ;
16618 PyObject * obj1 = 0 ;
16619 char *kwnames[] = {
16620 (char *) "self",(char *) "i", NULL
16621 };
16622
16623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
16624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16625 if (SWIG_arg_fail(1)) SWIG_fail;
16626 {
16627 arg2 = static_cast<int >(SWIG_As_int(obj1));
16628 if (SWIG_arg_fail(2)) SWIG_fail;
16629 }
16630 {
16631 PyThreadState* __tstate = wxPyBeginAllowThreads();
16632 (arg1)->SetInt(arg2);
16633
16634 wxPyEndAllowThreads(__tstate);
16635 if (PyErr_Occurred()) SWIG_fail;
16636 }
16637 Py_INCREF(Py_None); resultobj = Py_None;
16638 return resultobj;
16639 fail:
16640 return NULL;
16641 }
16642
16643
16644 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16645 PyObject *resultobj = NULL;
16646 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16647 long result;
16648 PyObject * obj0 = 0 ;
16649 char *kwnames[] = {
16650 (char *) "self", NULL
16651 };
16652
16653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
16654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16655 if (SWIG_arg_fail(1)) SWIG_fail;
16656 {
16657 PyThreadState* __tstate = wxPyBeginAllowThreads();
16658 result = (long)((wxCommandEvent const *)arg1)->GetInt();
16659
16660 wxPyEndAllowThreads(__tstate);
16661 if (PyErr_Occurred()) SWIG_fail;
16662 }
16663 {
16664 resultobj = SWIG_From_long(static_cast<long >(result));
16665 }
16666 return resultobj;
16667 fail:
16668 return NULL;
16669 }
16670
16671
16672 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16673 PyObject *resultobj = NULL;
16674 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16675 wxEvent *result;
16676 PyObject * obj0 = 0 ;
16677 char *kwnames[] = {
16678 (char *) "self", NULL
16679 };
16680
16681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
16682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16683 if (SWIG_arg_fail(1)) SWIG_fail;
16684 {
16685 PyThreadState* __tstate = wxPyBeginAllowThreads();
16686 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
16687
16688 wxPyEndAllowThreads(__tstate);
16689 if (PyErr_Occurred()) SWIG_fail;
16690 }
16691 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16692 return resultobj;
16693 fail:
16694 return NULL;
16695 }
16696
16697
16698 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
16699 PyObject *obj;
16700 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16701 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
16702 Py_INCREF(obj);
16703 return Py_BuildValue((char *)"");
16704 }
16705 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16706 PyObject *resultobj = NULL;
16707 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16708 int arg2 = (int) 0 ;
16709 wxNotifyEvent *result;
16710 PyObject * obj0 = 0 ;
16711 PyObject * obj1 = 0 ;
16712 char *kwnames[] = {
16713 (char *) "commandType",(char *) "winid", NULL
16714 };
16715
16716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
16717 if (obj0) {
16718 {
16719 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16720 if (SWIG_arg_fail(1)) SWIG_fail;
16721 }
16722 }
16723 if (obj1) {
16724 {
16725 arg2 = static_cast<int >(SWIG_As_int(obj1));
16726 if (SWIG_arg_fail(2)) SWIG_fail;
16727 }
16728 }
16729 {
16730 PyThreadState* __tstate = wxPyBeginAllowThreads();
16731 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
16732
16733 wxPyEndAllowThreads(__tstate);
16734 if (PyErr_Occurred()) SWIG_fail;
16735 }
16736 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
16737 return resultobj;
16738 fail:
16739 return NULL;
16740 }
16741
16742
16743 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
16744 PyObject *resultobj = NULL;
16745 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16746 PyObject * obj0 = 0 ;
16747 char *kwnames[] = {
16748 (char *) "self", NULL
16749 };
16750
16751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
16752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16753 if (SWIG_arg_fail(1)) SWIG_fail;
16754 {
16755 PyThreadState* __tstate = wxPyBeginAllowThreads();
16756 (arg1)->Veto();
16757
16758 wxPyEndAllowThreads(__tstate);
16759 if (PyErr_Occurred()) SWIG_fail;
16760 }
16761 Py_INCREF(Py_None); resultobj = Py_None;
16762 return resultobj;
16763 fail:
16764 return NULL;
16765 }
16766
16767
16768 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
16769 PyObject *resultobj = NULL;
16770 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16771 PyObject * obj0 = 0 ;
16772 char *kwnames[] = {
16773 (char *) "self", NULL
16774 };
16775
16776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16778 if (SWIG_arg_fail(1)) SWIG_fail;
16779 {
16780 PyThreadState* __tstate = wxPyBeginAllowThreads();
16781 (arg1)->Allow();
16782
16783 wxPyEndAllowThreads(__tstate);
16784 if (PyErr_Occurred()) SWIG_fail;
16785 }
16786 Py_INCREF(Py_None); resultobj = Py_None;
16787 return resultobj;
16788 fail:
16789 return NULL;
16790 }
16791
16792
16793 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16794 PyObject *resultobj = NULL;
16795 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16796 bool result;
16797 PyObject * obj0 = 0 ;
16798 char *kwnames[] = {
16799 (char *) "self", NULL
16800 };
16801
16802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16804 if (SWIG_arg_fail(1)) SWIG_fail;
16805 {
16806 PyThreadState* __tstate = wxPyBeginAllowThreads();
16807 result = (bool)(arg1)->IsAllowed();
16808
16809 wxPyEndAllowThreads(__tstate);
16810 if (PyErr_Occurred()) SWIG_fail;
16811 }
16812 {
16813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16814 }
16815 return resultobj;
16816 fail:
16817 return NULL;
16818 }
16819
16820
16821 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16822 PyObject *obj;
16823 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16824 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16825 Py_INCREF(obj);
16826 return Py_BuildValue((char *)"");
16827 }
16828 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16829 PyObject *resultobj = NULL;
16830 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16831 int arg2 = (int) 0 ;
16832 int arg3 = (int) 0 ;
16833 int arg4 = (int) 0 ;
16834 wxScrollEvent *result;
16835 PyObject * obj0 = 0 ;
16836 PyObject * obj1 = 0 ;
16837 PyObject * obj2 = 0 ;
16838 PyObject * obj3 = 0 ;
16839 char *kwnames[] = {
16840 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16841 };
16842
16843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16844 if (obj0) {
16845 {
16846 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16847 if (SWIG_arg_fail(1)) SWIG_fail;
16848 }
16849 }
16850 if (obj1) {
16851 {
16852 arg2 = static_cast<int >(SWIG_As_int(obj1));
16853 if (SWIG_arg_fail(2)) SWIG_fail;
16854 }
16855 }
16856 if (obj2) {
16857 {
16858 arg3 = static_cast<int >(SWIG_As_int(obj2));
16859 if (SWIG_arg_fail(3)) SWIG_fail;
16860 }
16861 }
16862 if (obj3) {
16863 {
16864 arg4 = static_cast<int >(SWIG_As_int(obj3));
16865 if (SWIG_arg_fail(4)) SWIG_fail;
16866 }
16867 }
16868 {
16869 PyThreadState* __tstate = wxPyBeginAllowThreads();
16870 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16871
16872 wxPyEndAllowThreads(__tstate);
16873 if (PyErr_Occurred()) SWIG_fail;
16874 }
16875 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16876 return resultobj;
16877 fail:
16878 return NULL;
16879 }
16880
16881
16882 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16883 PyObject *resultobj = NULL;
16884 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16885 int result;
16886 PyObject * obj0 = 0 ;
16887 char *kwnames[] = {
16888 (char *) "self", NULL
16889 };
16890
16891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16893 if (SWIG_arg_fail(1)) SWIG_fail;
16894 {
16895 PyThreadState* __tstate = wxPyBeginAllowThreads();
16896 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16897
16898 wxPyEndAllowThreads(__tstate);
16899 if (PyErr_Occurred()) SWIG_fail;
16900 }
16901 {
16902 resultobj = SWIG_From_int(static_cast<int >(result));
16903 }
16904 return resultobj;
16905 fail:
16906 return NULL;
16907 }
16908
16909
16910 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16911 PyObject *resultobj = NULL;
16912 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16913 int result;
16914 PyObject * obj0 = 0 ;
16915 char *kwnames[] = {
16916 (char *) "self", NULL
16917 };
16918
16919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16921 if (SWIG_arg_fail(1)) SWIG_fail;
16922 {
16923 PyThreadState* __tstate = wxPyBeginAllowThreads();
16924 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16925
16926 wxPyEndAllowThreads(__tstate);
16927 if (PyErr_Occurred()) SWIG_fail;
16928 }
16929 {
16930 resultobj = SWIG_From_int(static_cast<int >(result));
16931 }
16932 return resultobj;
16933 fail:
16934 return NULL;
16935 }
16936
16937
16938 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16939 PyObject *resultobj = NULL;
16940 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16941 int arg2 ;
16942 PyObject * obj0 = 0 ;
16943 PyObject * obj1 = 0 ;
16944 char *kwnames[] = {
16945 (char *) "self",(char *) "orient", NULL
16946 };
16947
16948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16950 if (SWIG_arg_fail(1)) SWIG_fail;
16951 {
16952 arg2 = static_cast<int >(SWIG_As_int(obj1));
16953 if (SWIG_arg_fail(2)) SWIG_fail;
16954 }
16955 {
16956 PyThreadState* __tstate = wxPyBeginAllowThreads();
16957 (arg1)->SetOrientation(arg2);
16958
16959 wxPyEndAllowThreads(__tstate);
16960 if (PyErr_Occurred()) SWIG_fail;
16961 }
16962 Py_INCREF(Py_None); resultobj = Py_None;
16963 return resultobj;
16964 fail:
16965 return NULL;
16966 }
16967
16968
16969 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16970 PyObject *resultobj = NULL;
16971 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16972 int arg2 ;
16973 PyObject * obj0 = 0 ;
16974 PyObject * obj1 = 0 ;
16975 char *kwnames[] = {
16976 (char *) "self",(char *) "pos", NULL
16977 };
16978
16979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16981 if (SWIG_arg_fail(1)) SWIG_fail;
16982 {
16983 arg2 = static_cast<int >(SWIG_As_int(obj1));
16984 if (SWIG_arg_fail(2)) SWIG_fail;
16985 }
16986 {
16987 PyThreadState* __tstate = wxPyBeginAllowThreads();
16988 (arg1)->SetPosition(arg2);
16989
16990 wxPyEndAllowThreads(__tstate);
16991 if (PyErr_Occurred()) SWIG_fail;
16992 }
16993 Py_INCREF(Py_None); resultobj = Py_None;
16994 return resultobj;
16995 fail:
16996 return NULL;
16997 }
16998
16999
17000 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
17001 PyObject *obj;
17002 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17003 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
17004 Py_INCREF(obj);
17005 return Py_BuildValue((char *)"");
17006 }
17007 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17008 PyObject *resultobj = NULL;
17009 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17010 int arg2 = (int) 0 ;
17011 int arg3 = (int) 0 ;
17012 wxScrollWinEvent *result;
17013 PyObject * obj0 = 0 ;
17014 PyObject * obj1 = 0 ;
17015 PyObject * obj2 = 0 ;
17016 char *kwnames[] = {
17017 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
17018 };
17019
17020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
17021 if (obj0) {
17022 {
17023 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
17024 if (SWIG_arg_fail(1)) SWIG_fail;
17025 }
17026 }
17027 if (obj1) {
17028 {
17029 arg2 = static_cast<int >(SWIG_As_int(obj1));
17030 if (SWIG_arg_fail(2)) SWIG_fail;
17031 }
17032 }
17033 if (obj2) {
17034 {
17035 arg3 = static_cast<int >(SWIG_As_int(obj2));
17036 if (SWIG_arg_fail(3)) SWIG_fail;
17037 }
17038 }
17039 {
17040 PyThreadState* __tstate = wxPyBeginAllowThreads();
17041 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
17042
17043 wxPyEndAllowThreads(__tstate);
17044 if (PyErr_Occurred()) SWIG_fail;
17045 }
17046 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
17047 return resultobj;
17048 fail:
17049 return NULL;
17050 }
17051
17052
17053 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17054 PyObject *resultobj = NULL;
17055 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17056 int result;
17057 PyObject * obj0 = 0 ;
17058 char *kwnames[] = {
17059 (char *) "self", NULL
17060 };
17061
17062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
17063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17064 if (SWIG_arg_fail(1)) SWIG_fail;
17065 {
17066 PyThreadState* __tstate = wxPyBeginAllowThreads();
17067 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
17068
17069 wxPyEndAllowThreads(__tstate);
17070 if (PyErr_Occurred()) SWIG_fail;
17071 }
17072 {
17073 resultobj = SWIG_From_int(static_cast<int >(result));
17074 }
17075 return resultobj;
17076 fail:
17077 return NULL;
17078 }
17079
17080
17081 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17082 PyObject *resultobj = NULL;
17083 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17084 int result;
17085 PyObject * obj0 = 0 ;
17086 char *kwnames[] = {
17087 (char *) "self", NULL
17088 };
17089
17090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
17091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17092 if (SWIG_arg_fail(1)) SWIG_fail;
17093 {
17094 PyThreadState* __tstate = wxPyBeginAllowThreads();
17095 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
17096
17097 wxPyEndAllowThreads(__tstate);
17098 if (PyErr_Occurred()) SWIG_fail;
17099 }
17100 {
17101 resultobj = SWIG_From_int(static_cast<int >(result));
17102 }
17103 return resultobj;
17104 fail:
17105 return NULL;
17106 }
17107
17108
17109 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17110 PyObject *resultobj = NULL;
17111 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17112 int arg2 ;
17113 PyObject * obj0 = 0 ;
17114 PyObject * obj1 = 0 ;
17115 char *kwnames[] = {
17116 (char *) "self",(char *) "orient", NULL
17117 };
17118
17119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
17120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17121 if (SWIG_arg_fail(1)) SWIG_fail;
17122 {
17123 arg2 = static_cast<int >(SWIG_As_int(obj1));
17124 if (SWIG_arg_fail(2)) SWIG_fail;
17125 }
17126 {
17127 PyThreadState* __tstate = wxPyBeginAllowThreads();
17128 (arg1)->SetOrientation(arg2);
17129
17130 wxPyEndAllowThreads(__tstate);
17131 if (PyErr_Occurred()) SWIG_fail;
17132 }
17133 Py_INCREF(Py_None); resultobj = Py_None;
17134 return resultobj;
17135 fail:
17136 return NULL;
17137 }
17138
17139
17140 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17141 PyObject *resultobj = NULL;
17142 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17143 int arg2 ;
17144 PyObject * obj0 = 0 ;
17145 PyObject * obj1 = 0 ;
17146 char *kwnames[] = {
17147 (char *) "self",(char *) "pos", NULL
17148 };
17149
17150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
17151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17152 if (SWIG_arg_fail(1)) SWIG_fail;
17153 {
17154 arg2 = static_cast<int >(SWIG_As_int(obj1));
17155 if (SWIG_arg_fail(2)) SWIG_fail;
17156 }
17157 {
17158 PyThreadState* __tstate = wxPyBeginAllowThreads();
17159 (arg1)->SetPosition(arg2);
17160
17161 wxPyEndAllowThreads(__tstate);
17162 if (PyErr_Occurred()) SWIG_fail;
17163 }
17164 Py_INCREF(Py_None); resultobj = Py_None;
17165 return resultobj;
17166 fail:
17167 return NULL;
17168 }
17169
17170
17171 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
17172 PyObject *obj;
17173 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17174 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
17175 Py_INCREF(obj);
17176 return Py_BuildValue((char *)"");
17177 }
17178 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17179 PyObject *resultobj = NULL;
17180 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17181 wxMouseEvent *result;
17182 PyObject * obj0 = 0 ;
17183 char *kwnames[] = {
17184 (char *) "mouseType", NULL
17185 };
17186
17187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
17188 if (obj0) {
17189 {
17190 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
17191 if (SWIG_arg_fail(1)) SWIG_fail;
17192 }
17193 }
17194 {
17195 PyThreadState* __tstate = wxPyBeginAllowThreads();
17196 result = (wxMouseEvent *)new wxMouseEvent(arg1);
17197
17198 wxPyEndAllowThreads(__tstate);
17199 if (PyErr_Occurred()) SWIG_fail;
17200 }
17201 {
17202 resultobj = wxPyMake_wxObject(result, (bool)1);
17203 }
17204 return resultobj;
17205 fail:
17206 return NULL;
17207 }
17208
17209
17210 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
17211 PyObject *resultobj = NULL;
17212 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17213 bool result;
17214 PyObject * obj0 = 0 ;
17215 char *kwnames[] = {
17216 (char *) "self", NULL
17217 };
17218
17219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
17220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17221 if (SWIG_arg_fail(1)) SWIG_fail;
17222 {
17223 PyThreadState* __tstate = wxPyBeginAllowThreads();
17224 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
17225
17226 wxPyEndAllowThreads(__tstate);
17227 if (PyErr_Occurred()) SWIG_fail;
17228 }
17229 {
17230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17231 }
17232 return resultobj;
17233 fail:
17234 return NULL;
17235 }
17236
17237
17238 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
17239 PyObject *resultobj = NULL;
17240 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17241 int arg2 = (int) wxMOUSE_BTN_ANY ;
17242 bool result;
17243 PyObject * obj0 = 0 ;
17244 PyObject * obj1 = 0 ;
17245 char *kwnames[] = {
17246 (char *) "self",(char *) "but", NULL
17247 };
17248
17249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
17250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17251 if (SWIG_arg_fail(1)) SWIG_fail;
17252 if (obj1) {
17253 {
17254 arg2 = static_cast<int >(SWIG_As_int(obj1));
17255 if (SWIG_arg_fail(2)) SWIG_fail;
17256 }
17257 }
17258 {
17259 PyThreadState* __tstate = wxPyBeginAllowThreads();
17260 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
17261
17262 wxPyEndAllowThreads(__tstate);
17263 if (PyErr_Occurred()) SWIG_fail;
17264 }
17265 {
17266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17267 }
17268 return resultobj;
17269 fail:
17270 return NULL;
17271 }
17272
17273
17274 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17275 PyObject *resultobj = NULL;
17276 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17277 int arg2 = (int) wxMOUSE_BTN_ANY ;
17278 bool result;
17279 PyObject * obj0 = 0 ;
17280 PyObject * obj1 = 0 ;
17281 char *kwnames[] = {
17282 (char *) "self",(char *) "but", NULL
17283 };
17284
17285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
17286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17287 if (SWIG_arg_fail(1)) SWIG_fail;
17288 if (obj1) {
17289 {
17290 arg2 = static_cast<int >(SWIG_As_int(obj1));
17291 if (SWIG_arg_fail(2)) SWIG_fail;
17292 }
17293 }
17294 {
17295 PyThreadState* __tstate = wxPyBeginAllowThreads();
17296 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
17297
17298 wxPyEndAllowThreads(__tstate);
17299 if (PyErr_Occurred()) SWIG_fail;
17300 }
17301 {
17302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17303 }
17304 return resultobj;
17305 fail:
17306 return NULL;
17307 }
17308
17309
17310 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
17311 PyObject *resultobj = NULL;
17312 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17313 int arg2 = (int) wxMOUSE_BTN_ANY ;
17314 bool result;
17315 PyObject * obj0 = 0 ;
17316 PyObject * obj1 = 0 ;
17317 char *kwnames[] = {
17318 (char *) "self",(char *) "but", NULL
17319 };
17320
17321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
17322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17323 if (SWIG_arg_fail(1)) SWIG_fail;
17324 if (obj1) {
17325 {
17326 arg2 = static_cast<int >(SWIG_As_int(obj1));
17327 if (SWIG_arg_fail(2)) SWIG_fail;
17328 }
17329 }
17330 {
17331 PyThreadState* __tstate = wxPyBeginAllowThreads();
17332 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
17333
17334 wxPyEndAllowThreads(__tstate);
17335 if (PyErr_Occurred()) SWIG_fail;
17336 }
17337 {
17338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17339 }
17340 return resultobj;
17341 fail:
17342 return NULL;
17343 }
17344
17345
17346 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
17347 PyObject *resultobj = NULL;
17348 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17349 int arg2 ;
17350 bool result;
17351 PyObject * obj0 = 0 ;
17352 PyObject * obj1 = 0 ;
17353 char *kwnames[] = {
17354 (char *) "self",(char *) "button", NULL
17355 };
17356
17357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
17358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17359 if (SWIG_arg_fail(1)) SWIG_fail;
17360 {
17361 arg2 = static_cast<int >(SWIG_As_int(obj1));
17362 if (SWIG_arg_fail(2)) SWIG_fail;
17363 }
17364 {
17365 PyThreadState* __tstate = wxPyBeginAllowThreads();
17366 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
17367
17368 wxPyEndAllowThreads(__tstate);
17369 if (PyErr_Occurred()) SWIG_fail;
17370 }
17371 {
17372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17373 }
17374 return resultobj;
17375 fail:
17376 return NULL;
17377 }
17378
17379
17380 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17381 PyObject *resultobj = NULL;
17382 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17383 int arg2 ;
17384 bool result;
17385 PyObject * obj0 = 0 ;
17386 PyObject * obj1 = 0 ;
17387 char *kwnames[] = {
17388 (char *) "self",(char *) "but", NULL
17389 };
17390
17391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
17392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17393 if (SWIG_arg_fail(1)) SWIG_fail;
17394 {
17395 arg2 = static_cast<int >(SWIG_As_int(obj1));
17396 if (SWIG_arg_fail(2)) SWIG_fail;
17397 }
17398 {
17399 PyThreadState* __tstate = wxPyBeginAllowThreads();
17400 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
17401
17402 wxPyEndAllowThreads(__tstate);
17403 if (PyErr_Occurred()) SWIG_fail;
17404 }
17405 {
17406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17407 }
17408 return resultobj;
17409 fail:
17410 return NULL;
17411 }
17412
17413
17414 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
17415 PyObject *resultobj = NULL;
17416 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17417 int result;
17418 PyObject * obj0 = 0 ;
17419 char *kwnames[] = {
17420 (char *) "self", NULL
17421 };
17422
17423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
17424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17425 if (SWIG_arg_fail(1)) SWIG_fail;
17426 {
17427 PyThreadState* __tstate = wxPyBeginAllowThreads();
17428 result = (int)((wxMouseEvent const *)arg1)->GetButton();
17429
17430 wxPyEndAllowThreads(__tstate);
17431 if (PyErr_Occurred()) SWIG_fail;
17432 }
17433 {
17434 resultobj = SWIG_From_int(static_cast<int >(result));
17435 }
17436 return resultobj;
17437 fail:
17438 return NULL;
17439 }
17440
17441
17442 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17443 PyObject *resultobj = NULL;
17444 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17445 bool result;
17446 PyObject * obj0 = 0 ;
17447 char *kwnames[] = {
17448 (char *) "self", NULL
17449 };
17450
17451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
17452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17453 if (SWIG_arg_fail(1)) SWIG_fail;
17454 {
17455 PyThreadState* __tstate = wxPyBeginAllowThreads();
17456 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
17457
17458 wxPyEndAllowThreads(__tstate);
17459 if (PyErr_Occurred()) SWIG_fail;
17460 }
17461 {
17462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17463 }
17464 return resultobj;
17465 fail:
17466 return NULL;
17467 }
17468
17469
17470 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17471 PyObject *resultobj = NULL;
17472 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17473 bool result;
17474 PyObject * obj0 = 0 ;
17475 char *kwnames[] = {
17476 (char *) "self", NULL
17477 };
17478
17479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
17480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17481 if (SWIG_arg_fail(1)) SWIG_fail;
17482 {
17483 PyThreadState* __tstate = wxPyBeginAllowThreads();
17484 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
17485
17486 wxPyEndAllowThreads(__tstate);
17487 if (PyErr_Occurred()) SWIG_fail;
17488 }
17489 {
17490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17491 }
17492 return resultobj;
17493 fail:
17494 return NULL;
17495 }
17496
17497
17498 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17499 PyObject *resultobj = NULL;
17500 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17501 bool result;
17502 PyObject * obj0 = 0 ;
17503 char *kwnames[] = {
17504 (char *) "self", NULL
17505 };
17506
17507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
17508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17509 if (SWIG_arg_fail(1)) SWIG_fail;
17510 {
17511 PyThreadState* __tstate = wxPyBeginAllowThreads();
17512 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
17513
17514 wxPyEndAllowThreads(__tstate);
17515 if (PyErr_Occurred()) SWIG_fail;
17516 }
17517 {
17518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17519 }
17520 return resultobj;
17521 fail:
17522 return NULL;
17523 }
17524
17525
17526 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17527 PyObject *resultobj = NULL;
17528 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17529 bool result;
17530 PyObject * obj0 = 0 ;
17531 char *kwnames[] = {
17532 (char *) "self", NULL
17533 };
17534
17535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
17536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17537 if (SWIG_arg_fail(1)) SWIG_fail;
17538 {
17539 PyThreadState* __tstate = wxPyBeginAllowThreads();
17540 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
17541
17542 wxPyEndAllowThreads(__tstate);
17543 if (PyErr_Occurred()) SWIG_fail;
17544 }
17545 {
17546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17547 }
17548 return resultobj;
17549 fail:
17550 return NULL;
17551 }
17552
17553
17554 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17555 PyObject *resultobj = NULL;
17556 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17557 bool result;
17558 PyObject * obj0 = 0 ;
17559 char *kwnames[] = {
17560 (char *) "self", NULL
17561 };
17562
17563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
17564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17565 if (SWIG_arg_fail(1)) SWIG_fail;
17566 {
17567 PyThreadState* __tstate = wxPyBeginAllowThreads();
17568 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
17569
17570 wxPyEndAllowThreads(__tstate);
17571 if (PyErr_Occurred()) SWIG_fail;
17572 }
17573 {
17574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17575 }
17576 return resultobj;
17577 fail:
17578 return NULL;
17579 }
17580
17581
17582 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17583 PyObject *resultobj = NULL;
17584 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17585 bool result;
17586 PyObject * obj0 = 0 ;
17587 char *kwnames[] = {
17588 (char *) "self", NULL
17589 };
17590
17591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
17592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17593 if (SWIG_arg_fail(1)) SWIG_fail;
17594 {
17595 PyThreadState* __tstate = wxPyBeginAllowThreads();
17596 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
17597
17598 wxPyEndAllowThreads(__tstate);
17599 if (PyErr_Occurred()) SWIG_fail;
17600 }
17601 {
17602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17603 }
17604 return resultobj;
17605 fail:
17606 return NULL;
17607 }
17608
17609
17610 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
17611 PyObject *resultobj = NULL;
17612 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17613 bool result;
17614 PyObject * obj0 = 0 ;
17615 char *kwnames[] = {
17616 (char *) "self", NULL
17617 };
17618
17619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
17620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17621 if (SWIG_arg_fail(1)) SWIG_fail;
17622 {
17623 PyThreadState* __tstate = wxPyBeginAllowThreads();
17624 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
17625
17626 wxPyEndAllowThreads(__tstate);
17627 if (PyErr_Occurred()) SWIG_fail;
17628 }
17629 {
17630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17631 }
17632 return resultobj;
17633 fail:
17634 return NULL;
17635 }
17636
17637
17638 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
17639 PyObject *resultobj = NULL;
17640 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17641 bool result;
17642 PyObject * obj0 = 0 ;
17643 char *kwnames[] = {
17644 (char *) "self", NULL
17645 };
17646
17647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
17648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17649 if (SWIG_arg_fail(1)) SWIG_fail;
17650 {
17651 PyThreadState* __tstate = wxPyBeginAllowThreads();
17652 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
17653
17654 wxPyEndAllowThreads(__tstate);
17655 if (PyErr_Occurred()) SWIG_fail;
17656 }
17657 {
17658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17659 }
17660 return resultobj;
17661 fail:
17662 return NULL;
17663 }
17664
17665
17666 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
17667 PyObject *resultobj = NULL;
17668 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17669 bool result;
17670 PyObject * obj0 = 0 ;
17671 char *kwnames[] = {
17672 (char *) "self", NULL
17673 };
17674
17675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
17676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17677 if (SWIG_arg_fail(1)) SWIG_fail;
17678 {
17679 PyThreadState* __tstate = wxPyBeginAllowThreads();
17680 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
17681
17682 wxPyEndAllowThreads(__tstate);
17683 if (PyErr_Occurred()) SWIG_fail;
17684 }
17685 {
17686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17687 }
17688 return resultobj;
17689 fail:
17690 return NULL;
17691 }
17692
17693
17694 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
17695 PyObject *resultobj = NULL;
17696 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17697 bool result;
17698 PyObject * obj0 = 0 ;
17699 char *kwnames[] = {
17700 (char *) "self", NULL
17701 };
17702
17703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
17704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17705 if (SWIG_arg_fail(1)) SWIG_fail;
17706 {
17707 PyThreadState* __tstate = wxPyBeginAllowThreads();
17708 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
17709
17710 wxPyEndAllowThreads(__tstate);
17711 if (PyErr_Occurred()) SWIG_fail;
17712 }
17713 {
17714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17715 }
17716 return resultobj;
17717 fail:
17718 return NULL;
17719 }
17720
17721
17722 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
17723 PyObject *resultobj = NULL;
17724 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17725 bool result;
17726 PyObject * obj0 = 0 ;
17727 char *kwnames[] = {
17728 (char *) "self", NULL
17729 };
17730
17731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
17732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17733 if (SWIG_arg_fail(1)) SWIG_fail;
17734 {
17735 PyThreadState* __tstate = wxPyBeginAllowThreads();
17736 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
17737
17738 wxPyEndAllowThreads(__tstate);
17739 if (PyErr_Occurred()) SWIG_fail;
17740 }
17741 {
17742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17743 }
17744 return resultobj;
17745 fail:
17746 return NULL;
17747 }
17748
17749
17750 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17751 PyObject *resultobj = NULL;
17752 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17753 bool result;
17754 PyObject * obj0 = 0 ;
17755 char *kwnames[] = {
17756 (char *) "self", NULL
17757 };
17758
17759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
17760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17761 if (SWIG_arg_fail(1)) SWIG_fail;
17762 {
17763 PyThreadState* __tstate = wxPyBeginAllowThreads();
17764 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
17765
17766 wxPyEndAllowThreads(__tstate);
17767 if (PyErr_Occurred()) SWIG_fail;
17768 }
17769 {
17770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17771 }
17772 return resultobj;
17773 fail:
17774 return NULL;
17775 }
17776
17777
17778 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17779 PyObject *resultobj = NULL;
17780 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17781 bool result;
17782 PyObject * obj0 = 0 ;
17783 char *kwnames[] = {
17784 (char *) "self", NULL
17785 };
17786
17787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17789 if (SWIG_arg_fail(1)) SWIG_fail;
17790 {
17791 PyThreadState* __tstate = wxPyBeginAllowThreads();
17792 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17793
17794 wxPyEndAllowThreads(__tstate);
17795 if (PyErr_Occurred()) SWIG_fail;
17796 }
17797 {
17798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17799 }
17800 return resultobj;
17801 fail:
17802 return NULL;
17803 }
17804
17805
17806 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17807 PyObject *resultobj = NULL;
17808 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17809 bool result;
17810 PyObject * obj0 = 0 ;
17811 char *kwnames[] = {
17812 (char *) "self", NULL
17813 };
17814
17815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17817 if (SWIG_arg_fail(1)) SWIG_fail;
17818 {
17819 PyThreadState* __tstate = wxPyBeginAllowThreads();
17820 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17821
17822 wxPyEndAllowThreads(__tstate);
17823 if (PyErr_Occurred()) SWIG_fail;
17824 }
17825 {
17826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17827 }
17828 return resultobj;
17829 fail:
17830 return NULL;
17831 }
17832
17833
17834 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17835 PyObject *resultobj = NULL;
17836 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17837 bool result;
17838 PyObject * obj0 = 0 ;
17839 char *kwnames[] = {
17840 (char *) "self", NULL
17841 };
17842
17843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17845 if (SWIG_arg_fail(1)) SWIG_fail;
17846 {
17847 PyThreadState* __tstate = wxPyBeginAllowThreads();
17848 result = (bool)(arg1)->LeftIsDown();
17849
17850 wxPyEndAllowThreads(__tstate);
17851 if (PyErr_Occurred()) SWIG_fail;
17852 }
17853 {
17854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17855 }
17856 return resultobj;
17857 fail:
17858 return NULL;
17859 }
17860
17861
17862 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17863 PyObject *resultobj = NULL;
17864 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17865 bool result;
17866 PyObject * obj0 = 0 ;
17867 char *kwnames[] = {
17868 (char *) "self", NULL
17869 };
17870
17871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17873 if (SWIG_arg_fail(1)) SWIG_fail;
17874 {
17875 PyThreadState* __tstate = wxPyBeginAllowThreads();
17876 result = (bool)(arg1)->MiddleIsDown();
17877
17878 wxPyEndAllowThreads(__tstate);
17879 if (PyErr_Occurred()) SWIG_fail;
17880 }
17881 {
17882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17883 }
17884 return resultobj;
17885 fail:
17886 return NULL;
17887 }
17888
17889
17890 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17891 PyObject *resultobj = NULL;
17892 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17893 bool result;
17894 PyObject * obj0 = 0 ;
17895 char *kwnames[] = {
17896 (char *) "self", NULL
17897 };
17898
17899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17901 if (SWIG_arg_fail(1)) SWIG_fail;
17902 {
17903 PyThreadState* __tstate = wxPyBeginAllowThreads();
17904 result = (bool)(arg1)->RightIsDown();
17905
17906 wxPyEndAllowThreads(__tstate);
17907 if (PyErr_Occurred()) SWIG_fail;
17908 }
17909 {
17910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17911 }
17912 return resultobj;
17913 fail:
17914 return NULL;
17915 }
17916
17917
17918 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17919 PyObject *resultobj = NULL;
17920 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17921 bool result;
17922 PyObject * obj0 = 0 ;
17923 char *kwnames[] = {
17924 (char *) "self", NULL
17925 };
17926
17927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17929 if (SWIG_arg_fail(1)) SWIG_fail;
17930 {
17931 PyThreadState* __tstate = wxPyBeginAllowThreads();
17932 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17933
17934 wxPyEndAllowThreads(__tstate);
17935 if (PyErr_Occurred()) SWIG_fail;
17936 }
17937 {
17938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17939 }
17940 return resultobj;
17941 fail:
17942 return NULL;
17943 }
17944
17945
17946 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17947 PyObject *resultobj = NULL;
17948 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17949 bool result;
17950 PyObject * obj0 = 0 ;
17951 char *kwnames[] = {
17952 (char *) "self", NULL
17953 };
17954
17955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17957 if (SWIG_arg_fail(1)) SWIG_fail;
17958 {
17959 PyThreadState* __tstate = wxPyBeginAllowThreads();
17960 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17961
17962 wxPyEndAllowThreads(__tstate);
17963 if (PyErr_Occurred()) SWIG_fail;
17964 }
17965 {
17966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17967 }
17968 return resultobj;
17969 fail:
17970 return NULL;
17971 }
17972
17973
17974 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17975 PyObject *resultobj = NULL;
17976 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17977 bool result;
17978 PyObject * obj0 = 0 ;
17979 char *kwnames[] = {
17980 (char *) "self", NULL
17981 };
17982
17983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17985 if (SWIG_arg_fail(1)) SWIG_fail;
17986 {
17987 PyThreadState* __tstate = wxPyBeginAllowThreads();
17988 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17989
17990 wxPyEndAllowThreads(__tstate);
17991 if (PyErr_Occurred()) SWIG_fail;
17992 }
17993 {
17994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17995 }
17996 return resultobj;
17997 fail:
17998 return NULL;
17999 }
18000
18001
18002 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
18003 PyObject *resultobj = NULL;
18004 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18005 bool result;
18006 PyObject * obj0 = 0 ;
18007 char *kwnames[] = {
18008 (char *) "self", NULL
18009 };
18010
18011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
18012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18013 if (SWIG_arg_fail(1)) SWIG_fail;
18014 {
18015 PyThreadState* __tstate = wxPyBeginAllowThreads();
18016 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
18017
18018 wxPyEndAllowThreads(__tstate);
18019 if (PyErr_Occurred()) SWIG_fail;
18020 }
18021 {
18022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18023 }
18024 return resultobj;
18025 fail:
18026 return NULL;
18027 }
18028
18029
18030 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18031 PyObject *resultobj = NULL;
18032 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18033 wxPoint result;
18034 PyObject * obj0 = 0 ;
18035 char *kwnames[] = {
18036 (char *) "self", NULL
18037 };
18038
18039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
18040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18041 if (SWIG_arg_fail(1)) SWIG_fail;
18042 {
18043 PyThreadState* __tstate = wxPyBeginAllowThreads();
18044 result = (arg1)->GetPosition();
18045
18046 wxPyEndAllowThreads(__tstate);
18047 if (PyErr_Occurred()) SWIG_fail;
18048 }
18049 {
18050 wxPoint * resultptr;
18051 resultptr = new wxPoint(static_cast<wxPoint & >(result));
18052 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18053 }
18054 return resultobj;
18055 fail:
18056 return NULL;
18057 }
18058
18059
18060 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18061 PyObject *resultobj = NULL;
18062 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18063 long *arg2 = (long *) 0 ;
18064 long *arg3 = (long *) 0 ;
18065 long temp2 ;
18066 int res2 = 0 ;
18067 long temp3 ;
18068 int res3 = 0 ;
18069 PyObject * obj0 = 0 ;
18070 char *kwnames[] = {
18071 (char *) "self", NULL
18072 };
18073
18074 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18075 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18078 if (SWIG_arg_fail(1)) SWIG_fail;
18079 {
18080 PyThreadState* __tstate = wxPyBeginAllowThreads();
18081 (arg1)->GetPosition(arg2,arg3);
18082
18083 wxPyEndAllowThreads(__tstate);
18084 if (PyErr_Occurred()) SWIG_fail;
18085 }
18086 Py_INCREF(Py_None); resultobj = Py_None;
18087 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18088 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18089 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18090 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18091 return resultobj;
18092 fail:
18093 return NULL;
18094 }
18095
18096
18097 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18098 PyObject *resultobj = NULL;
18099 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18100 wxDC *arg2 = 0 ;
18101 wxPoint result;
18102 PyObject * obj0 = 0 ;
18103 PyObject * obj1 = 0 ;
18104 char *kwnames[] = {
18105 (char *) "self",(char *) "dc", NULL
18106 };
18107
18108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
18109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18110 if (SWIG_arg_fail(1)) SWIG_fail;
18111 {
18112 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18113 if (SWIG_arg_fail(2)) SWIG_fail;
18114 if (arg2 == NULL) {
18115 SWIG_null_ref("wxDC");
18116 }
18117 if (SWIG_arg_fail(2)) SWIG_fail;
18118 }
18119 {
18120 PyThreadState* __tstate = wxPyBeginAllowThreads();
18121 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
18122
18123 wxPyEndAllowThreads(__tstate);
18124 if (PyErr_Occurred()) SWIG_fail;
18125 }
18126 {
18127 wxPoint * resultptr;
18128 resultptr = new wxPoint(static_cast<wxPoint & >(result));
18129 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18130 }
18131 return resultobj;
18132 fail:
18133 return NULL;
18134 }
18135
18136
18137 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18138 PyObject *resultobj = NULL;
18139 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18140 int result;
18141 PyObject * obj0 = 0 ;
18142 char *kwnames[] = {
18143 (char *) "self", NULL
18144 };
18145
18146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
18147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18148 if (SWIG_arg_fail(1)) SWIG_fail;
18149 {
18150 PyThreadState* __tstate = wxPyBeginAllowThreads();
18151 result = (int)((wxMouseEvent const *)arg1)->GetX();
18152
18153 wxPyEndAllowThreads(__tstate);
18154 if (PyErr_Occurred()) SWIG_fail;
18155 }
18156 {
18157 resultobj = SWIG_From_int(static_cast<int >(result));
18158 }
18159 return resultobj;
18160 fail:
18161 return NULL;
18162 }
18163
18164
18165 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18166 PyObject *resultobj = NULL;
18167 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18168 int result;
18169 PyObject * obj0 = 0 ;
18170 char *kwnames[] = {
18171 (char *) "self", NULL
18172 };
18173
18174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
18175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18176 if (SWIG_arg_fail(1)) SWIG_fail;
18177 {
18178 PyThreadState* __tstate = wxPyBeginAllowThreads();
18179 result = (int)((wxMouseEvent const *)arg1)->GetY();
18180
18181 wxPyEndAllowThreads(__tstate);
18182 if (PyErr_Occurred()) SWIG_fail;
18183 }
18184 {
18185 resultobj = SWIG_From_int(static_cast<int >(result));
18186 }
18187 return resultobj;
18188 fail:
18189 return NULL;
18190 }
18191
18192
18193 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
18194 PyObject *resultobj = NULL;
18195 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18196 int result;
18197 PyObject * obj0 = 0 ;
18198 char *kwnames[] = {
18199 (char *) "self", NULL
18200 };
18201
18202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
18203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18204 if (SWIG_arg_fail(1)) SWIG_fail;
18205 {
18206 PyThreadState* __tstate = wxPyBeginAllowThreads();
18207 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
18208
18209 wxPyEndAllowThreads(__tstate);
18210 if (PyErr_Occurred()) SWIG_fail;
18211 }
18212 {
18213 resultobj = SWIG_From_int(static_cast<int >(result));
18214 }
18215 return resultobj;
18216 fail:
18217 return NULL;
18218 }
18219
18220
18221 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
18222 PyObject *resultobj = NULL;
18223 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18224 int result;
18225 PyObject * obj0 = 0 ;
18226 char *kwnames[] = {
18227 (char *) "self", NULL
18228 };
18229
18230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
18231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18232 if (SWIG_arg_fail(1)) SWIG_fail;
18233 {
18234 PyThreadState* __tstate = wxPyBeginAllowThreads();
18235 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
18236
18237 wxPyEndAllowThreads(__tstate);
18238 if (PyErr_Occurred()) SWIG_fail;
18239 }
18240 {
18241 resultobj = SWIG_From_int(static_cast<int >(result));
18242 }
18243 return resultobj;
18244 fail:
18245 return NULL;
18246 }
18247
18248
18249 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
18250 PyObject *resultobj = NULL;
18251 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18252 int result;
18253 PyObject * obj0 = 0 ;
18254 char *kwnames[] = {
18255 (char *) "self", NULL
18256 };
18257
18258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
18259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18260 if (SWIG_arg_fail(1)) SWIG_fail;
18261 {
18262 PyThreadState* __tstate = wxPyBeginAllowThreads();
18263 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
18264
18265 wxPyEndAllowThreads(__tstate);
18266 if (PyErr_Occurred()) SWIG_fail;
18267 }
18268 {
18269 resultobj = SWIG_From_int(static_cast<int >(result));
18270 }
18271 return resultobj;
18272 fail:
18273 return NULL;
18274 }
18275
18276
18277 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
18278 PyObject *resultobj = NULL;
18279 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18280 bool result;
18281 PyObject * obj0 = 0 ;
18282 char *kwnames[] = {
18283 (char *) "self", NULL
18284 };
18285
18286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
18287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18288 if (SWIG_arg_fail(1)) SWIG_fail;
18289 {
18290 PyThreadState* __tstate = wxPyBeginAllowThreads();
18291 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
18292
18293 wxPyEndAllowThreads(__tstate);
18294 if (PyErr_Occurred()) SWIG_fail;
18295 }
18296 {
18297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18298 }
18299 return resultobj;
18300 fail:
18301 return NULL;
18302 }
18303
18304
18305 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18306 PyObject *resultobj = NULL;
18307 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18308 int arg2 ;
18309 PyObject * obj0 = 0 ;
18310 PyObject * obj1 = 0 ;
18311 char *kwnames[] = {
18312 (char *) "self",(char *) "m_x", NULL
18313 };
18314
18315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18317 if (SWIG_arg_fail(1)) SWIG_fail;
18318 {
18319 arg2 = static_cast<int >(SWIG_As_int(obj1));
18320 if (SWIG_arg_fail(2)) SWIG_fail;
18321 }
18322 if (arg1) (arg1)->m_x = arg2;
18323
18324 Py_INCREF(Py_None); resultobj = Py_None;
18325 return resultobj;
18326 fail:
18327 return NULL;
18328 }
18329
18330
18331 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18332 PyObject *resultobj = NULL;
18333 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18334 int result;
18335 PyObject * obj0 = 0 ;
18336 char *kwnames[] = {
18337 (char *) "self", NULL
18338 };
18339
18340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
18341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18342 if (SWIG_arg_fail(1)) SWIG_fail;
18343 result = (int) ((arg1)->m_x);
18344
18345 {
18346 resultobj = SWIG_From_int(static_cast<int >(result));
18347 }
18348 return resultobj;
18349 fail:
18350 return NULL;
18351 }
18352
18353
18354 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18355 PyObject *resultobj = NULL;
18356 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18357 int arg2 ;
18358 PyObject * obj0 = 0 ;
18359 PyObject * obj1 = 0 ;
18360 char *kwnames[] = {
18361 (char *) "self",(char *) "m_y", NULL
18362 };
18363
18364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18366 if (SWIG_arg_fail(1)) SWIG_fail;
18367 {
18368 arg2 = static_cast<int >(SWIG_As_int(obj1));
18369 if (SWIG_arg_fail(2)) SWIG_fail;
18370 }
18371 if (arg1) (arg1)->m_y = arg2;
18372
18373 Py_INCREF(Py_None); resultobj = Py_None;
18374 return resultobj;
18375 fail:
18376 return NULL;
18377 }
18378
18379
18380 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18381 PyObject *resultobj = NULL;
18382 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18383 int result;
18384 PyObject * obj0 = 0 ;
18385 char *kwnames[] = {
18386 (char *) "self", NULL
18387 };
18388
18389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
18390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18391 if (SWIG_arg_fail(1)) SWIG_fail;
18392 result = (int) ((arg1)->m_y);
18393
18394 {
18395 resultobj = SWIG_From_int(static_cast<int >(result));
18396 }
18397 return resultobj;
18398 fail:
18399 return NULL;
18400 }
18401
18402
18403 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18404 PyObject *resultobj = NULL;
18405 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18406 bool arg2 ;
18407 PyObject * obj0 = 0 ;
18408 PyObject * obj1 = 0 ;
18409 char *kwnames[] = {
18410 (char *) "self",(char *) "m_leftDown", NULL
18411 };
18412
18413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
18414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18415 if (SWIG_arg_fail(1)) SWIG_fail;
18416 {
18417 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18418 if (SWIG_arg_fail(2)) SWIG_fail;
18419 }
18420 if (arg1) (arg1)->m_leftDown = arg2;
18421
18422 Py_INCREF(Py_None); resultobj = Py_None;
18423 return resultobj;
18424 fail:
18425 return NULL;
18426 }
18427
18428
18429 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18430 PyObject *resultobj = NULL;
18431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18432 bool result;
18433 PyObject * obj0 = 0 ;
18434 char *kwnames[] = {
18435 (char *) "self", NULL
18436 };
18437
18438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
18439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18440 if (SWIG_arg_fail(1)) SWIG_fail;
18441 result = (bool) ((arg1)->m_leftDown);
18442
18443 {
18444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18445 }
18446 return resultobj;
18447 fail:
18448 return NULL;
18449 }
18450
18451
18452 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18453 PyObject *resultobj = NULL;
18454 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18455 bool arg2 ;
18456 PyObject * obj0 = 0 ;
18457 PyObject * obj1 = 0 ;
18458 char *kwnames[] = {
18459 (char *) "self",(char *) "m_middleDown", NULL
18460 };
18461
18462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
18463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18464 if (SWIG_arg_fail(1)) SWIG_fail;
18465 {
18466 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18467 if (SWIG_arg_fail(2)) SWIG_fail;
18468 }
18469 if (arg1) (arg1)->m_middleDown = arg2;
18470
18471 Py_INCREF(Py_None); resultobj = Py_None;
18472 return resultobj;
18473 fail:
18474 return NULL;
18475 }
18476
18477
18478 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18479 PyObject *resultobj = NULL;
18480 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18481 bool result;
18482 PyObject * obj0 = 0 ;
18483 char *kwnames[] = {
18484 (char *) "self", NULL
18485 };
18486
18487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
18488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18489 if (SWIG_arg_fail(1)) SWIG_fail;
18490 result = (bool) ((arg1)->m_middleDown);
18491
18492 {
18493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18494 }
18495 return resultobj;
18496 fail:
18497 return NULL;
18498 }
18499
18500
18501 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18502 PyObject *resultobj = NULL;
18503 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18504 bool arg2 ;
18505 PyObject * obj0 = 0 ;
18506 PyObject * obj1 = 0 ;
18507 char *kwnames[] = {
18508 (char *) "self",(char *) "m_rightDown", NULL
18509 };
18510
18511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
18512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18513 if (SWIG_arg_fail(1)) SWIG_fail;
18514 {
18515 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18516 if (SWIG_arg_fail(2)) SWIG_fail;
18517 }
18518 if (arg1) (arg1)->m_rightDown = arg2;
18519
18520 Py_INCREF(Py_None); resultobj = Py_None;
18521 return resultobj;
18522 fail:
18523 return NULL;
18524 }
18525
18526
18527 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18528 PyObject *resultobj = NULL;
18529 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18530 bool result;
18531 PyObject * obj0 = 0 ;
18532 char *kwnames[] = {
18533 (char *) "self", NULL
18534 };
18535
18536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
18537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18538 if (SWIG_arg_fail(1)) SWIG_fail;
18539 result = (bool) ((arg1)->m_rightDown);
18540
18541 {
18542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18543 }
18544 return resultobj;
18545 fail:
18546 return NULL;
18547 }
18548
18549
18550 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18551 PyObject *resultobj = NULL;
18552 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18553 bool arg2 ;
18554 PyObject * obj0 = 0 ;
18555 PyObject * obj1 = 0 ;
18556 char *kwnames[] = {
18557 (char *) "self",(char *) "m_controlDown", NULL
18558 };
18559
18560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18562 if (SWIG_arg_fail(1)) SWIG_fail;
18563 {
18564 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18565 if (SWIG_arg_fail(2)) SWIG_fail;
18566 }
18567 if (arg1) (arg1)->m_controlDown = arg2;
18568
18569 Py_INCREF(Py_None); resultobj = Py_None;
18570 return resultobj;
18571 fail:
18572 return NULL;
18573 }
18574
18575
18576 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18577 PyObject *resultobj = NULL;
18578 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18579 bool result;
18580 PyObject * obj0 = 0 ;
18581 char *kwnames[] = {
18582 (char *) "self", NULL
18583 };
18584
18585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18587 if (SWIG_arg_fail(1)) SWIG_fail;
18588 result = (bool) ((arg1)->m_controlDown);
18589
18590 {
18591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18592 }
18593 return resultobj;
18594 fail:
18595 return NULL;
18596 }
18597
18598
18599 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18600 PyObject *resultobj = NULL;
18601 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18602 bool arg2 ;
18603 PyObject * obj0 = 0 ;
18604 PyObject * obj1 = 0 ;
18605 char *kwnames[] = {
18606 (char *) "self",(char *) "m_shiftDown", NULL
18607 };
18608
18609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18611 if (SWIG_arg_fail(1)) SWIG_fail;
18612 {
18613 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18614 if (SWIG_arg_fail(2)) SWIG_fail;
18615 }
18616 if (arg1) (arg1)->m_shiftDown = arg2;
18617
18618 Py_INCREF(Py_None); resultobj = Py_None;
18619 return resultobj;
18620 fail:
18621 return NULL;
18622 }
18623
18624
18625 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18626 PyObject *resultobj = NULL;
18627 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18628 bool result;
18629 PyObject * obj0 = 0 ;
18630 char *kwnames[] = {
18631 (char *) "self", NULL
18632 };
18633
18634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18636 if (SWIG_arg_fail(1)) SWIG_fail;
18637 result = (bool) ((arg1)->m_shiftDown);
18638
18639 {
18640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18641 }
18642 return resultobj;
18643 fail:
18644 return NULL;
18645 }
18646
18647
18648 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18649 PyObject *resultobj = NULL;
18650 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18651 bool arg2 ;
18652 PyObject * obj0 = 0 ;
18653 PyObject * obj1 = 0 ;
18654 char *kwnames[] = {
18655 (char *) "self",(char *) "m_altDown", NULL
18656 };
18657
18658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18660 if (SWIG_arg_fail(1)) SWIG_fail;
18661 {
18662 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18663 if (SWIG_arg_fail(2)) SWIG_fail;
18664 }
18665 if (arg1) (arg1)->m_altDown = arg2;
18666
18667 Py_INCREF(Py_None); resultobj = Py_None;
18668 return resultobj;
18669 fail:
18670 return NULL;
18671 }
18672
18673
18674 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18675 PyObject *resultobj = NULL;
18676 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18677 bool result;
18678 PyObject * obj0 = 0 ;
18679 char *kwnames[] = {
18680 (char *) "self", NULL
18681 };
18682
18683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18685 if (SWIG_arg_fail(1)) SWIG_fail;
18686 result = (bool) ((arg1)->m_altDown);
18687
18688 {
18689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18690 }
18691 return resultobj;
18692 fail:
18693 return NULL;
18694 }
18695
18696
18697 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18698 PyObject *resultobj = NULL;
18699 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18700 bool arg2 ;
18701 PyObject * obj0 = 0 ;
18702 PyObject * obj1 = 0 ;
18703 char *kwnames[] = {
18704 (char *) "self",(char *) "m_metaDown", NULL
18705 };
18706
18707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18709 if (SWIG_arg_fail(1)) SWIG_fail;
18710 {
18711 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18712 if (SWIG_arg_fail(2)) SWIG_fail;
18713 }
18714 if (arg1) (arg1)->m_metaDown = arg2;
18715
18716 Py_INCREF(Py_None); resultobj = Py_None;
18717 return resultobj;
18718 fail:
18719 return NULL;
18720 }
18721
18722
18723 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18724 PyObject *resultobj = NULL;
18725 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18726 bool result;
18727 PyObject * obj0 = 0 ;
18728 char *kwnames[] = {
18729 (char *) "self", NULL
18730 };
18731
18732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18734 if (SWIG_arg_fail(1)) SWIG_fail;
18735 result = (bool) ((arg1)->m_metaDown);
18736
18737 {
18738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18739 }
18740 return resultobj;
18741 fail:
18742 return NULL;
18743 }
18744
18745
18746 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
18747 PyObject *resultobj = NULL;
18748 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18749 int arg2 ;
18750 PyObject * obj0 = 0 ;
18751 PyObject * obj1 = 0 ;
18752 char *kwnames[] = {
18753 (char *) "self",(char *) "m_wheelRotation", NULL
18754 };
18755
18756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
18757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18758 if (SWIG_arg_fail(1)) SWIG_fail;
18759 {
18760 arg2 = static_cast<int >(SWIG_As_int(obj1));
18761 if (SWIG_arg_fail(2)) SWIG_fail;
18762 }
18763 if (arg1) (arg1)->m_wheelRotation = arg2;
18764
18765 Py_INCREF(Py_None); resultobj = Py_None;
18766 return resultobj;
18767 fail:
18768 return NULL;
18769 }
18770
18771
18772 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
18773 PyObject *resultobj = NULL;
18774 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18775 int result;
18776 PyObject * obj0 = 0 ;
18777 char *kwnames[] = {
18778 (char *) "self", NULL
18779 };
18780
18781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18783 if (SWIG_arg_fail(1)) SWIG_fail;
18784 result = (int) ((arg1)->m_wheelRotation);
18785
18786 {
18787 resultobj = SWIG_From_int(static_cast<int >(result));
18788 }
18789 return resultobj;
18790 fail:
18791 return NULL;
18792 }
18793
18794
18795 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18796 PyObject *resultobj = NULL;
18797 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18798 int arg2 ;
18799 PyObject * obj0 = 0 ;
18800 PyObject * obj1 = 0 ;
18801 char *kwnames[] = {
18802 (char *) "self",(char *) "m_wheelDelta", NULL
18803 };
18804
18805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18807 if (SWIG_arg_fail(1)) SWIG_fail;
18808 {
18809 arg2 = static_cast<int >(SWIG_As_int(obj1));
18810 if (SWIG_arg_fail(2)) SWIG_fail;
18811 }
18812 if (arg1) (arg1)->m_wheelDelta = arg2;
18813
18814 Py_INCREF(Py_None); resultobj = Py_None;
18815 return resultobj;
18816 fail:
18817 return NULL;
18818 }
18819
18820
18821 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18822 PyObject *resultobj = NULL;
18823 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18824 int result;
18825 PyObject * obj0 = 0 ;
18826 char *kwnames[] = {
18827 (char *) "self", NULL
18828 };
18829
18830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18832 if (SWIG_arg_fail(1)) SWIG_fail;
18833 result = (int) ((arg1)->m_wheelDelta);
18834
18835 {
18836 resultobj = SWIG_From_int(static_cast<int >(result));
18837 }
18838 return resultobj;
18839 fail:
18840 return NULL;
18841 }
18842
18843
18844 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18845 PyObject *resultobj = NULL;
18846 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18847 int arg2 ;
18848 PyObject * obj0 = 0 ;
18849 PyObject * obj1 = 0 ;
18850 char *kwnames[] = {
18851 (char *) "self",(char *) "m_linesPerAction", NULL
18852 };
18853
18854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18856 if (SWIG_arg_fail(1)) SWIG_fail;
18857 {
18858 arg2 = static_cast<int >(SWIG_As_int(obj1));
18859 if (SWIG_arg_fail(2)) SWIG_fail;
18860 }
18861 if (arg1) (arg1)->m_linesPerAction = arg2;
18862
18863 Py_INCREF(Py_None); resultobj = Py_None;
18864 return resultobj;
18865 fail:
18866 return NULL;
18867 }
18868
18869
18870 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18871 PyObject *resultobj = NULL;
18872 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18873 int result;
18874 PyObject * obj0 = 0 ;
18875 char *kwnames[] = {
18876 (char *) "self", NULL
18877 };
18878
18879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18881 if (SWIG_arg_fail(1)) SWIG_fail;
18882 result = (int) ((arg1)->m_linesPerAction);
18883
18884 {
18885 resultobj = SWIG_From_int(static_cast<int >(result));
18886 }
18887 return resultobj;
18888 fail:
18889 return NULL;
18890 }
18891
18892
18893 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18894 PyObject *obj;
18895 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18896 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18897 Py_INCREF(obj);
18898 return Py_BuildValue((char *)"");
18899 }
18900 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18901 PyObject *resultobj = NULL;
18902 int arg1 = (int) 0 ;
18903 int arg2 = (int) 0 ;
18904 wxSetCursorEvent *result;
18905 PyObject * obj0 = 0 ;
18906 PyObject * obj1 = 0 ;
18907 char *kwnames[] = {
18908 (char *) "x",(char *) "y", NULL
18909 };
18910
18911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18912 if (obj0) {
18913 {
18914 arg1 = static_cast<int >(SWIG_As_int(obj0));
18915 if (SWIG_arg_fail(1)) SWIG_fail;
18916 }
18917 }
18918 if (obj1) {
18919 {
18920 arg2 = static_cast<int >(SWIG_As_int(obj1));
18921 if (SWIG_arg_fail(2)) SWIG_fail;
18922 }
18923 }
18924 {
18925 PyThreadState* __tstate = wxPyBeginAllowThreads();
18926 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18927
18928 wxPyEndAllowThreads(__tstate);
18929 if (PyErr_Occurred()) SWIG_fail;
18930 }
18931 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18932 return resultobj;
18933 fail:
18934 return NULL;
18935 }
18936
18937
18938 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18939 PyObject *resultobj = NULL;
18940 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18941 int result;
18942 PyObject * obj0 = 0 ;
18943 char *kwnames[] = {
18944 (char *) "self", NULL
18945 };
18946
18947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18949 if (SWIG_arg_fail(1)) SWIG_fail;
18950 {
18951 PyThreadState* __tstate = wxPyBeginAllowThreads();
18952 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18953
18954 wxPyEndAllowThreads(__tstate);
18955 if (PyErr_Occurred()) SWIG_fail;
18956 }
18957 {
18958 resultobj = SWIG_From_int(static_cast<int >(result));
18959 }
18960 return resultobj;
18961 fail:
18962 return NULL;
18963 }
18964
18965
18966 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18967 PyObject *resultobj = NULL;
18968 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18969 int result;
18970 PyObject * obj0 = 0 ;
18971 char *kwnames[] = {
18972 (char *) "self", NULL
18973 };
18974
18975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18977 if (SWIG_arg_fail(1)) SWIG_fail;
18978 {
18979 PyThreadState* __tstate = wxPyBeginAllowThreads();
18980 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18981
18982 wxPyEndAllowThreads(__tstate);
18983 if (PyErr_Occurred()) SWIG_fail;
18984 }
18985 {
18986 resultobj = SWIG_From_int(static_cast<int >(result));
18987 }
18988 return resultobj;
18989 fail:
18990 return NULL;
18991 }
18992
18993
18994 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18995 PyObject *resultobj = NULL;
18996 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18997 wxCursor *arg2 = 0 ;
18998 PyObject * obj0 = 0 ;
18999 PyObject * obj1 = 0 ;
19000 char *kwnames[] = {
19001 (char *) "self",(char *) "cursor", NULL
19002 };
19003
19004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
19005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19006 if (SWIG_arg_fail(1)) SWIG_fail;
19007 {
19008 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
19009 if (SWIG_arg_fail(2)) SWIG_fail;
19010 if (arg2 == NULL) {
19011 SWIG_null_ref("wxCursor");
19012 }
19013 if (SWIG_arg_fail(2)) SWIG_fail;
19014 }
19015 {
19016 PyThreadState* __tstate = wxPyBeginAllowThreads();
19017 (arg1)->SetCursor((wxCursor const &)*arg2);
19018
19019 wxPyEndAllowThreads(__tstate);
19020 if (PyErr_Occurred()) SWIG_fail;
19021 }
19022 Py_INCREF(Py_None); resultobj = Py_None;
19023 return resultobj;
19024 fail:
19025 return NULL;
19026 }
19027
19028
19029 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19030 PyObject *resultobj = NULL;
19031 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19032 wxCursor *result;
19033 PyObject * obj0 = 0 ;
19034 char *kwnames[] = {
19035 (char *) "self", NULL
19036 };
19037
19038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
19039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19040 if (SWIG_arg_fail(1)) SWIG_fail;
19041 {
19042 PyThreadState* __tstate = wxPyBeginAllowThreads();
19043 {
19044 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
19045 result = (wxCursor *) &_result_ref;
19046 }
19047
19048 wxPyEndAllowThreads(__tstate);
19049 if (PyErr_Occurred()) SWIG_fail;
19050 }
19051 {
19052 wxCursor* resultptr = new wxCursor(*result);
19053 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
19054 }
19055 return resultobj;
19056 fail:
19057 return NULL;
19058 }
19059
19060
19061 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19062 PyObject *resultobj = NULL;
19063 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19064 bool result;
19065 PyObject * obj0 = 0 ;
19066 char *kwnames[] = {
19067 (char *) "self", NULL
19068 };
19069
19070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
19071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19072 if (SWIG_arg_fail(1)) SWIG_fail;
19073 {
19074 PyThreadState* __tstate = wxPyBeginAllowThreads();
19075 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
19076
19077 wxPyEndAllowThreads(__tstate);
19078 if (PyErr_Occurred()) SWIG_fail;
19079 }
19080 {
19081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19082 }
19083 return resultobj;
19084 fail:
19085 return NULL;
19086 }
19087
19088
19089 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
19090 PyObject *obj;
19091 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19092 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
19093 Py_INCREF(obj);
19094 return Py_BuildValue((char *)"");
19095 }
19096 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19097 PyObject *resultobj = NULL;
19098 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19099 wxKeyEvent *result;
19100 PyObject * obj0 = 0 ;
19101 char *kwnames[] = {
19102 (char *) "eventType", NULL
19103 };
19104
19105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
19106 if (obj0) {
19107 {
19108 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
19109 if (SWIG_arg_fail(1)) SWIG_fail;
19110 }
19111 }
19112 {
19113 PyThreadState* __tstate = wxPyBeginAllowThreads();
19114 result = (wxKeyEvent *)new wxKeyEvent(arg1);
19115
19116 wxPyEndAllowThreads(__tstate);
19117 if (PyErr_Occurred()) SWIG_fail;
19118 }
19119 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
19120 return resultobj;
19121 fail:
19122 return NULL;
19123 }
19124
19125
19126 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
19127 PyObject *resultobj = NULL;
19128 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19129 bool result;
19130 PyObject * obj0 = 0 ;
19131 char *kwnames[] = {
19132 (char *) "self", NULL
19133 };
19134
19135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
19136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19137 if (SWIG_arg_fail(1)) SWIG_fail;
19138 {
19139 PyThreadState* __tstate = wxPyBeginAllowThreads();
19140 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
19141
19142 wxPyEndAllowThreads(__tstate);
19143 if (PyErr_Occurred()) SWIG_fail;
19144 }
19145 {
19146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19147 }
19148 return resultobj;
19149 fail:
19150 return NULL;
19151 }
19152
19153
19154 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
19155 PyObject *resultobj = NULL;
19156 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19157 bool result;
19158 PyObject * obj0 = 0 ;
19159 char *kwnames[] = {
19160 (char *) "self", NULL
19161 };
19162
19163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
19164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19165 if (SWIG_arg_fail(1)) SWIG_fail;
19166 {
19167 PyThreadState* __tstate = wxPyBeginAllowThreads();
19168 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
19169
19170 wxPyEndAllowThreads(__tstate);
19171 if (PyErr_Occurred()) SWIG_fail;
19172 }
19173 {
19174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19175 }
19176 return resultobj;
19177 fail:
19178 return NULL;
19179 }
19180
19181
19182 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
19183 PyObject *resultobj = NULL;
19184 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19185 bool result;
19186 PyObject * obj0 = 0 ;
19187 char *kwnames[] = {
19188 (char *) "self", NULL
19189 };
19190
19191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
19192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19193 if (SWIG_arg_fail(1)) SWIG_fail;
19194 {
19195 PyThreadState* __tstate = wxPyBeginAllowThreads();
19196 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
19197
19198 wxPyEndAllowThreads(__tstate);
19199 if (PyErr_Occurred()) SWIG_fail;
19200 }
19201 {
19202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19203 }
19204 return resultobj;
19205 fail:
19206 return NULL;
19207 }
19208
19209
19210 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
19211 PyObject *resultobj = NULL;
19212 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19213 bool result;
19214 PyObject * obj0 = 0 ;
19215 char *kwnames[] = {
19216 (char *) "self", NULL
19217 };
19218
19219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
19220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19221 if (SWIG_arg_fail(1)) SWIG_fail;
19222 {
19223 PyThreadState* __tstate = wxPyBeginAllowThreads();
19224 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
19225
19226 wxPyEndAllowThreads(__tstate);
19227 if (PyErr_Occurred()) SWIG_fail;
19228 }
19229 {
19230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19231 }
19232 return resultobj;
19233 fail:
19234 return NULL;
19235 }
19236
19237
19238 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
19239 PyObject *resultobj = NULL;
19240 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19241 bool result;
19242 PyObject * obj0 = 0 ;
19243 char *kwnames[] = {
19244 (char *) "self", NULL
19245 };
19246
19247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
19248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19249 if (SWIG_arg_fail(1)) SWIG_fail;
19250 {
19251 PyThreadState* __tstate = wxPyBeginAllowThreads();
19252 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
19253
19254 wxPyEndAllowThreads(__tstate);
19255 if (PyErr_Occurred()) SWIG_fail;
19256 }
19257 {
19258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19259 }
19260 return resultobj;
19261 fail:
19262 return NULL;
19263 }
19264
19265
19266 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
19267 PyObject *resultobj = NULL;
19268 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19269 bool result;
19270 PyObject * obj0 = 0 ;
19271 char *kwnames[] = {
19272 (char *) "self", NULL
19273 };
19274
19275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
19276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19277 if (SWIG_arg_fail(1)) SWIG_fail;
19278 {
19279 PyThreadState* __tstate = wxPyBeginAllowThreads();
19280 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
19281
19282 wxPyEndAllowThreads(__tstate);
19283 if (PyErr_Occurred()) SWIG_fail;
19284 }
19285 {
19286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19287 }
19288 return resultobj;
19289 fail:
19290 return NULL;
19291 }
19292
19293
19294 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19295 PyObject *resultobj = NULL;
19296 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19297 int result;
19298 PyObject * obj0 = 0 ;
19299 char *kwnames[] = {
19300 (char *) "self", NULL
19301 };
19302
19303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
19304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19305 if (SWIG_arg_fail(1)) SWIG_fail;
19306 {
19307 PyThreadState* __tstate = wxPyBeginAllowThreads();
19308 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
19309
19310 wxPyEndAllowThreads(__tstate);
19311 if (PyErr_Occurred()) SWIG_fail;
19312 }
19313 {
19314 resultobj = SWIG_From_int(static_cast<int >(result));
19315 }
19316 return resultobj;
19317 fail:
19318 return NULL;
19319 }
19320
19321
19322 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
19323 PyObject *resultobj = NULL;
19324 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19325 int result;
19326 PyObject * obj0 = 0 ;
19327 char *kwnames[] = {
19328 (char *) "self", NULL
19329 };
19330
19331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
19332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19333 if (SWIG_arg_fail(1)) SWIG_fail;
19334 {
19335 PyThreadState* __tstate = wxPyBeginAllowThreads();
19336 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
19337
19338 wxPyEndAllowThreads(__tstate);
19339 if (PyErr_Occurred()) SWIG_fail;
19340 }
19341 {
19342 resultobj = SWIG_From_int(static_cast<int >(result));
19343 }
19344 return resultobj;
19345 fail:
19346 return NULL;
19347 }
19348
19349
19350 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19351 PyObject *resultobj = NULL;
19352 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19353 unsigned int result;
19354 PyObject * obj0 = 0 ;
19355 char *kwnames[] = {
19356 (char *) "self", NULL
19357 };
19358
19359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
19360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19361 if (SWIG_arg_fail(1)) SWIG_fail;
19362 {
19363 PyThreadState* __tstate = wxPyBeginAllowThreads();
19364 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
19365
19366 wxPyEndAllowThreads(__tstate);
19367 if (PyErr_Occurred()) SWIG_fail;
19368 }
19369 {
19370 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19371 }
19372 return resultobj;
19373 fail:
19374 return NULL;
19375 }
19376
19377
19378 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
19379 PyObject *resultobj = NULL;
19380 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19381 unsigned int result;
19382 PyObject * obj0 = 0 ;
19383 char *kwnames[] = {
19384 (char *) "self", NULL
19385 };
19386
19387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
19388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19389 if (SWIG_arg_fail(1)) SWIG_fail;
19390 {
19391 PyThreadState* __tstate = wxPyBeginAllowThreads();
19392 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
19393
19394 wxPyEndAllowThreads(__tstate);
19395 if (PyErr_Occurred()) SWIG_fail;
19396 }
19397 {
19398 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19399 }
19400 return resultobj;
19401 fail:
19402 return NULL;
19403 }
19404
19405
19406 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19407 PyObject *resultobj = NULL;
19408 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19409 wxPoint result;
19410 PyObject * obj0 = 0 ;
19411 char *kwnames[] = {
19412 (char *) "self", NULL
19413 };
19414
19415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
19416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19417 if (SWIG_arg_fail(1)) SWIG_fail;
19418 {
19419 PyThreadState* __tstate = wxPyBeginAllowThreads();
19420 result = (arg1)->GetPosition();
19421
19422 wxPyEndAllowThreads(__tstate);
19423 if (PyErr_Occurred()) SWIG_fail;
19424 }
19425 {
19426 wxPoint * resultptr;
19427 resultptr = new wxPoint(static_cast<wxPoint & >(result));
19428 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19429 }
19430 return resultobj;
19431 fail:
19432 return NULL;
19433 }
19434
19435
19436 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
19437 PyObject *resultobj = NULL;
19438 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19439 long *arg2 = (long *) 0 ;
19440 long *arg3 = (long *) 0 ;
19441 long temp2 ;
19442 int res2 = 0 ;
19443 long temp3 ;
19444 int res3 = 0 ;
19445 PyObject * obj0 = 0 ;
19446 char *kwnames[] = {
19447 (char *) "self", NULL
19448 };
19449
19450 arg2 = &temp2; res2 = SWIG_NEWOBJ;
19451 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
19453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19454 if (SWIG_arg_fail(1)) SWIG_fail;
19455 {
19456 PyThreadState* __tstate = wxPyBeginAllowThreads();
19457 (arg1)->GetPosition(arg2,arg3);
19458
19459 wxPyEndAllowThreads(__tstate);
19460 if (PyErr_Occurred()) SWIG_fail;
19461 }
19462 Py_INCREF(Py_None); resultobj = Py_None;
19463 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19464 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
19465 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19466 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
19467 return resultobj;
19468 fail:
19469 return NULL;
19470 }
19471
19472
19473 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
19474 PyObject *resultobj = NULL;
19475 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19476 int result;
19477 PyObject * obj0 = 0 ;
19478 char *kwnames[] = {
19479 (char *) "self", NULL
19480 };
19481
19482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
19483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19484 if (SWIG_arg_fail(1)) SWIG_fail;
19485 {
19486 PyThreadState* __tstate = wxPyBeginAllowThreads();
19487 result = (int)((wxKeyEvent const *)arg1)->GetX();
19488
19489 wxPyEndAllowThreads(__tstate);
19490 if (PyErr_Occurred()) SWIG_fail;
19491 }
19492 {
19493 resultobj = SWIG_From_int(static_cast<int >(result));
19494 }
19495 return resultobj;
19496 fail:
19497 return NULL;
19498 }
19499
19500
19501 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
19502 PyObject *resultobj = NULL;
19503 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19504 int result;
19505 PyObject * obj0 = 0 ;
19506 char *kwnames[] = {
19507 (char *) "self", NULL
19508 };
19509
19510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
19511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19512 if (SWIG_arg_fail(1)) SWIG_fail;
19513 {
19514 PyThreadState* __tstate = wxPyBeginAllowThreads();
19515 result = (int)((wxKeyEvent const *)arg1)->GetY();
19516
19517 wxPyEndAllowThreads(__tstate);
19518 if (PyErr_Occurred()) SWIG_fail;
19519 }
19520 {
19521 resultobj = SWIG_From_int(static_cast<int >(result));
19522 }
19523 return resultobj;
19524 fail:
19525 return NULL;
19526 }
19527
19528
19529 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
19530 PyObject *resultobj = NULL;
19531 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19532 int arg2 ;
19533 PyObject * obj0 = 0 ;
19534 PyObject * obj1 = 0 ;
19535 char *kwnames[] = {
19536 (char *) "self",(char *) "m_x", NULL
19537 };
19538
19539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
19540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19541 if (SWIG_arg_fail(1)) SWIG_fail;
19542 {
19543 arg2 = static_cast<int >(SWIG_As_int(obj1));
19544 if (SWIG_arg_fail(2)) SWIG_fail;
19545 }
19546 if (arg1) (arg1)->m_x = arg2;
19547
19548 Py_INCREF(Py_None); resultobj = Py_None;
19549 return resultobj;
19550 fail:
19551 return NULL;
19552 }
19553
19554
19555 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
19556 PyObject *resultobj = NULL;
19557 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19558 int result;
19559 PyObject * obj0 = 0 ;
19560 char *kwnames[] = {
19561 (char *) "self", NULL
19562 };
19563
19564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
19565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19566 if (SWIG_arg_fail(1)) SWIG_fail;
19567 result = (int) ((arg1)->m_x);
19568
19569 {
19570 resultobj = SWIG_From_int(static_cast<int >(result));
19571 }
19572 return resultobj;
19573 fail:
19574 return NULL;
19575 }
19576
19577
19578 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
19579 PyObject *resultobj = NULL;
19580 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19581 int arg2 ;
19582 PyObject * obj0 = 0 ;
19583 PyObject * obj1 = 0 ;
19584 char *kwnames[] = {
19585 (char *) "self",(char *) "m_y", NULL
19586 };
19587
19588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
19589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19590 if (SWIG_arg_fail(1)) SWIG_fail;
19591 {
19592 arg2 = static_cast<int >(SWIG_As_int(obj1));
19593 if (SWIG_arg_fail(2)) SWIG_fail;
19594 }
19595 if (arg1) (arg1)->m_y = arg2;
19596
19597 Py_INCREF(Py_None); resultobj = Py_None;
19598 return resultobj;
19599 fail:
19600 return NULL;
19601 }
19602
19603
19604 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
19605 PyObject *resultobj = NULL;
19606 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19607 int result;
19608 PyObject * obj0 = 0 ;
19609 char *kwnames[] = {
19610 (char *) "self", NULL
19611 };
19612
19613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
19614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19615 if (SWIG_arg_fail(1)) SWIG_fail;
19616 result = (int) ((arg1)->m_y);
19617
19618 {
19619 resultobj = SWIG_From_int(static_cast<int >(result));
19620 }
19621 return resultobj;
19622 fail:
19623 return NULL;
19624 }
19625
19626
19627 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19628 PyObject *resultobj = NULL;
19629 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19630 long arg2 ;
19631 PyObject * obj0 = 0 ;
19632 PyObject * obj1 = 0 ;
19633 char *kwnames[] = {
19634 (char *) "self",(char *) "m_keyCode", NULL
19635 };
19636
19637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
19638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19639 if (SWIG_arg_fail(1)) SWIG_fail;
19640 {
19641 arg2 = static_cast<long >(SWIG_As_long(obj1));
19642 if (SWIG_arg_fail(2)) SWIG_fail;
19643 }
19644 if (arg1) (arg1)->m_keyCode = arg2;
19645
19646 Py_INCREF(Py_None); resultobj = Py_None;
19647 return resultobj;
19648 fail:
19649 return NULL;
19650 }
19651
19652
19653 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19654 PyObject *resultobj = NULL;
19655 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19656 long result;
19657 PyObject * obj0 = 0 ;
19658 char *kwnames[] = {
19659 (char *) "self", NULL
19660 };
19661
19662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
19663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19664 if (SWIG_arg_fail(1)) SWIG_fail;
19665 result = (long) ((arg1)->m_keyCode);
19666
19667 {
19668 resultobj = SWIG_From_long(static_cast<long >(result));
19669 }
19670 return resultobj;
19671 fail:
19672 return NULL;
19673 }
19674
19675
19676 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19677 PyObject *resultobj = NULL;
19678 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19679 bool arg2 ;
19680 PyObject * obj0 = 0 ;
19681 PyObject * obj1 = 0 ;
19682 char *kwnames[] = {
19683 (char *) "self",(char *) "m_controlDown", NULL
19684 };
19685
19686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
19687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19688 if (SWIG_arg_fail(1)) SWIG_fail;
19689 {
19690 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19691 if (SWIG_arg_fail(2)) SWIG_fail;
19692 }
19693 if (arg1) (arg1)->m_controlDown = arg2;
19694
19695 Py_INCREF(Py_None); resultobj = Py_None;
19696 return resultobj;
19697 fail:
19698 return NULL;
19699 }
19700
19701
19702 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19703 PyObject *resultobj = NULL;
19704 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19705 bool result;
19706 PyObject * obj0 = 0 ;
19707 char *kwnames[] = {
19708 (char *) "self", NULL
19709 };
19710
19711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
19712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19713 if (SWIG_arg_fail(1)) SWIG_fail;
19714 result = (bool) ((arg1)->m_controlDown);
19715
19716 {
19717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19718 }
19719 return resultobj;
19720 fail:
19721 return NULL;
19722 }
19723
19724
19725 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19726 PyObject *resultobj = NULL;
19727 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19728 bool arg2 ;
19729 PyObject * obj0 = 0 ;
19730 PyObject * obj1 = 0 ;
19731 char *kwnames[] = {
19732 (char *) "self",(char *) "m_shiftDown", NULL
19733 };
19734
19735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
19736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19737 if (SWIG_arg_fail(1)) SWIG_fail;
19738 {
19739 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19740 if (SWIG_arg_fail(2)) SWIG_fail;
19741 }
19742 if (arg1) (arg1)->m_shiftDown = arg2;
19743
19744 Py_INCREF(Py_None); resultobj = Py_None;
19745 return resultobj;
19746 fail:
19747 return NULL;
19748 }
19749
19750
19751 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19752 PyObject *resultobj = NULL;
19753 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19754 bool result;
19755 PyObject * obj0 = 0 ;
19756 char *kwnames[] = {
19757 (char *) "self", NULL
19758 };
19759
19760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
19761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19762 if (SWIG_arg_fail(1)) SWIG_fail;
19763 result = (bool) ((arg1)->m_shiftDown);
19764
19765 {
19766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19767 }
19768 return resultobj;
19769 fail:
19770 return NULL;
19771 }
19772
19773
19774 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19775 PyObject *resultobj = NULL;
19776 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19777 bool arg2 ;
19778 PyObject * obj0 = 0 ;
19779 PyObject * obj1 = 0 ;
19780 char *kwnames[] = {
19781 (char *) "self",(char *) "m_altDown", NULL
19782 };
19783
19784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19786 if (SWIG_arg_fail(1)) SWIG_fail;
19787 {
19788 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19789 if (SWIG_arg_fail(2)) SWIG_fail;
19790 }
19791 if (arg1) (arg1)->m_altDown = arg2;
19792
19793 Py_INCREF(Py_None); resultobj = Py_None;
19794 return resultobj;
19795 fail:
19796 return NULL;
19797 }
19798
19799
19800 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19801 PyObject *resultobj = NULL;
19802 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19803 bool result;
19804 PyObject * obj0 = 0 ;
19805 char *kwnames[] = {
19806 (char *) "self", NULL
19807 };
19808
19809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19811 if (SWIG_arg_fail(1)) SWIG_fail;
19812 result = (bool) ((arg1)->m_altDown);
19813
19814 {
19815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19816 }
19817 return resultobj;
19818 fail:
19819 return NULL;
19820 }
19821
19822
19823 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19824 PyObject *resultobj = NULL;
19825 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19826 bool arg2 ;
19827 PyObject * obj0 = 0 ;
19828 PyObject * obj1 = 0 ;
19829 char *kwnames[] = {
19830 (char *) "self",(char *) "m_metaDown", NULL
19831 };
19832
19833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19835 if (SWIG_arg_fail(1)) SWIG_fail;
19836 {
19837 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19838 if (SWIG_arg_fail(2)) SWIG_fail;
19839 }
19840 if (arg1) (arg1)->m_metaDown = arg2;
19841
19842 Py_INCREF(Py_None); resultobj = Py_None;
19843 return resultobj;
19844 fail:
19845 return NULL;
19846 }
19847
19848
19849 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19850 PyObject *resultobj = NULL;
19851 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19852 bool result;
19853 PyObject * obj0 = 0 ;
19854 char *kwnames[] = {
19855 (char *) "self", NULL
19856 };
19857
19858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19860 if (SWIG_arg_fail(1)) SWIG_fail;
19861 result = (bool) ((arg1)->m_metaDown);
19862
19863 {
19864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19865 }
19866 return resultobj;
19867 fail:
19868 return NULL;
19869 }
19870
19871
19872 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19873 PyObject *resultobj = NULL;
19874 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19875 bool arg2 ;
19876 PyObject * obj0 = 0 ;
19877 PyObject * obj1 = 0 ;
19878 char *kwnames[] = {
19879 (char *) "self",(char *) "m_scanCode", NULL
19880 };
19881
19882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19884 if (SWIG_arg_fail(1)) SWIG_fail;
19885 {
19886 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19887 if (SWIG_arg_fail(2)) SWIG_fail;
19888 }
19889 if (arg1) (arg1)->m_scanCode = arg2;
19890
19891 Py_INCREF(Py_None); resultobj = Py_None;
19892 return resultobj;
19893 fail:
19894 return NULL;
19895 }
19896
19897
19898 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19899 PyObject *resultobj = NULL;
19900 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19901 bool result;
19902 PyObject * obj0 = 0 ;
19903 char *kwnames[] = {
19904 (char *) "self", NULL
19905 };
19906
19907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19909 if (SWIG_arg_fail(1)) SWIG_fail;
19910 result = (bool) ((arg1)->m_scanCode);
19911
19912 {
19913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19914 }
19915 return resultobj;
19916 fail:
19917 return NULL;
19918 }
19919
19920
19921 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19922 PyObject *resultobj = NULL;
19923 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19924 unsigned int arg2 ;
19925 PyObject * obj0 = 0 ;
19926 PyObject * obj1 = 0 ;
19927 char *kwnames[] = {
19928 (char *) "self",(char *) "m_rawCode", NULL
19929 };
19930
19931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19933 if (SWIG_arg_fail(1)) SWIG_fail;
19934 {
19935 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
19936 if (SWIG_arg_fail(2)) SWIG_fail;
19937 }
19938 if (arg1) (arg1)->m_rawCode = arg2;
19939
19940 Py_INCREF(Py_None); resultobj = Py_None;
19941 return resultobj;
19942 fail:
19943 return NULL;
19944 }
19945
19946
19947 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19948 PyObject *resultobj = NULL;
19949 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19950 unsigned int result;
19951 PyObject * obj0 = 0 ;
19952 char *kwnames[] = {
19953 (char *) "self", NULL
19954 };
19955
19956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19958 if (SWIG_arg_fail(1)) SWIG_fail;
19959 result = (unsigned int) ((arg1)->m_rawCode);
19960
19961 {
19962 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19963 }
19964 return resultobj;
19965 fail:
19966 return NULL;
19967 }
19968
19969
19970 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19971 PyObject *resultobj = NULL;
19972 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19973 unsigned int arg2 ;
19974 PyObject * obj0 = 0 ;
19975 PyObject * obj1 = 0 ;
19976 char *kwnames[] = {
19977 (char *) "self",(char *) "m_rawFlags", NULL
19978 };
19979
19980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19982 if (SWIG_arg_fail(1)) SWIG_fail;
19983 {
19984 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
19985 if (SWIG_arg_fail(2)) SWIG_fail;
19986 }
19987 if (arg1) (arg1)->m_rawFlags = arg2;
19988
19989 Py_INCREF(Py_None); resultobj = Py_None;
19990 return resultobj;
19991 fail:
19992 return NULL;
19993 }
19994
19995
19996 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19997 PyObject *resultobj = NULL;
19998 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19999 unsigned int result;
20000 PyObject * obj0 = 0 ;
20001 char *kwnames[] = {
20002 (char *) "self", NULL
20003 };
20004
20005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
20006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
20007 if (SWIG_arg_fail(1)) SWIG_fail;
20008 result = (unsigned int) ((arg1)->m_rawFlags);
20009
20010 {
20011 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
20012 }
20013 return resultobj;
20014 fail:
20015 return NULL;
20016 }
20017
20018
20019 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
20020 PyObject *obj;
20021 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20022 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
20023 Py_INCREF(obj);
20024 return Py_BuildValue((char *)"");
20025 }
20026 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20027 PyObject *resultobj = NULL;
20028 wxSize const &arg1_defvalue = wxDefaultSize ;
20029 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
20030 int arg2 = (int) 0 ;
20031 wxSizeEvent *result;
20032 wxSize temp1 ;
20033 PyObject * obj0 = 0 ;
20034 PyObject * obj1 = 0 ;
20035 char *kwnames[] = {
20036 (char *) "sz",(char *) "winid", NULL
20037 };
20038
20039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
20040 if (obj0) {
20041 {
20042 arg1 = &temp1;
20043 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
20044 }
20045 }
20046 if (obj1) {
20047 {
20048 arg2 = static_cast<int >(SWIG_As_int(obj1));
20049 if (SWIG_arg_fail(2)) SWIG_fail;
20050 }
20051 }
20052 {
20053 PyThreadState* __tstate = wxPyBeginAllowThreads();
20054 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
20055
20056 wxPyEndAllowThreads(__tstate);
20057 if (PyErr_Occurred()) SWIG_fail;
20058 }
20059 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
20060 return resultobj;
20061 fail:
20062 return NULL;
20063 }
20064
20065
20066 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
20067 PyObject *resultobj = NULL;
20068 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20069 wxSize result;
20070 PyObject * obj0 = 0 ;
20071 char *kwnames[] = {
20072 (char *) "self", NULL
20073 };
20074
20075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
20076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20077 if (SWIG_arg_fail(1)) SWIG_fail;
20078 {
20079 PyThreadState* __tstate = wxPyBeginAllowThreads();
20080 result = ((wxSizeEvent const *)arg1)->GetSize();
20081
20082 wxPyEndAllowThreads(__tstate);
20083 if (PyErr_Occurred()) SWIG_fail;
20084 }
20085 {
20086 wxSize * resultptr;
20087 resultptr = new wxSize(static_cast<wxSize & >(result));
20088 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20089 }
20090 return resultobj;
20091 fail:
20092 return NULL;
20093 }
20094
20095
20096 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20097 PyObject *resultobj = NULL;
20098 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20099 wxRect result;
20100 PyObject * obj0 = 0 ;
20101 char *kwnames[] = {
20102 (char *) "self", NULL
20103 };
20104
20105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
20106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20107 if (SWIG_arg_fail(1)) SWIG_fail;
20108 {
20109 PyThreadState* __tstate = wxPyBeginAllowThreads();
20110 result = ((wxSizeEvent const *)arg1)->GetRect();
20111
20112 wxPyEndAllowThreads(__tstate);
20113 if (PyErr_Occurred()) SWIG_fail;
20114 }
20115 {
20116 wxRect * resultptr;
20117 resultptr = new wxRect(static_cast<wxRect & >(result));
20118 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20119 }
20120 return resultobj;
20121 fail:
20122 return NULL;
20123 }
20124
20125
20126 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20127 PyObject *resultobj = NULL;
20128 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20129 wxRect arg2 ;
20130 PyObject * obj0 = 0 ;
20131 PyObject * obj1 = 0 ;
20132 char *kwnames[] = {
20133 (char *) "self",(char *) "rect", NULL
20134 };
20135
20136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20138 if (SWIG_arg_fail(1)) SWIG_fail;
20139 {
20140 wxRect * argp;
20141 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
20142 if (SWIG_arg_fail(2)) SWIG_fail;
20143 if (argp == NULL) {
20144 SWIG_null_ref("wxRect");
20145 }
20146 if (SWIG_arg_fail(2)) SWIG_fail;
20147 arg2 = *argp;
20148 }
20149 {
20150 PyThreadState* __tstate = wxPyBeginAllowThreads();
20151 (arg1)->SetRect(arg2);
20152
20153 wxPyEndAllowThreads(__tstate);
20154 if (PyErr_Occurred()) SWIG_fail;
20155 }
20156 Py_INCREF(Py_None); resultobj = Py_None;
20157 return resultobj;
20158 fail:
20159 return NULL;
20160 }
20161
20162
20163 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
20164 PyObject *resultobj = NULL;
20165 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20166 wxSize arg2 ;
20167 PyObject * obj0 = 0 ;
20168 PyObject * obj1 = 0 ;
20169 char *kwnames[] = {
20170 (char *) "self",(char *) "size", NULL
20171 };
20172
20173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
20174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20175 if (SWIG_arg_fail(1)) SWIG_fail;
20176 {
20177 wxSize * argp;
20178 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
20179 if (SWIG_arg_fail(2)) SWIG_fail;
20180 if (argp == NULL) {
20181 SWIG_null_ref("wxSize");
20182 }
20183 if (SWIG_arg_fail(2)) SWIG_fail;
20184 arg2 = *argp;
20185 }
20186 {
20187 PyThreadState* __tstate = wxPyBeginAllowThreads();
20188 wxSizeEvent_SetSize(arg1,arg2);
20189
20190 wxPyEndAllowThreads(__tstate);
20191 if (PyErr_Occurred()) SWIG_fail;
20192 }
20193 Py_INCREF(Py_None); resultobj = Py_None;
20194 return resultobj;
20195 fail:
20196 return NULL;
20197 }
20198
20199
20200 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
20201 PyObject *resultobj = NULL;
20202 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20203 wxSize *arg2 = (wxSize *) 0 ;
20204 PyObject * obj0 = 0 ;
20205 PyObject * obj1 = 0 ;
20206 char *kwnames[] = {
20207 (char *) "self",(char *) "m_size", NULL
20208 };
20209
20210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
20211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20212 if (SWIG_arg_fail(1)) SWIG_fail;
20213 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
20214 if (SWIG_arg_fail(2)) SWIG_fail;
20215 if (arg1) (arg1)->m_size = *arg2;
20216
20217 Py_INCREF(Py_None); resultobj = Py_None;
20218 return resultobj;
20219 fail:
20220 return NULL;
20221 }
20222
20223
20224 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
20225 PyObject *resultobj = NULL;
20226 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20227 wxSize *result;
20228 PyObject * obj0 = 0 ;
20229 char *kwnames[] = {
20230 (char *) "self", NULL
20231 };
20232
20233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
20234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20235 if (SWIG_arg_fail(1)) SWIG_fail;
20236 result = (wxSize *)& ((arg1)->m_size);
20237
20238 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
20239 return resultobj;
20240 fail:
20241 return NULL;
20242 }
20243
20244
20245 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
20246 PyObject *resultobj = NULL;
20247 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20248 wxRect *arg2 = (wxRect *) 0 ;
20249 PyObject * obj0 = 0 ;
20250 PyObject * obj1 = 0 ;
20251 char *kwnames[] = {
20252 (char *) "self",(char *) "m_rect", NULL
20253 };
20254
20255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
20256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20257 if (SWIG_arg_fail(1)) SWIG_fail;
20258 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
20259 if (SWIG_arg_fail(2)) SWIG_fail;
20260 if (arg1) (arg1)->m_rect = *arg2;
20261
20262 Py_INCREF(Py_None); resultobj = Py_None;
20263 return resultobj;
20264 fail:
20265 return NULL;
20266 }
20267
20268
20269 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
20270 PyObject *resultobj = NULL;
20271 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20272 wxRect *result;
20273 PyObject * obj0 = 0 ;
20274 char *kwnames[] = {
20275 (char *) "self", NULL
20276 };
20277
20278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
20279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20280 if (SWIG_arg_fail(1)) SWIG_fail;
20281 result = (wxRect *)& ((arg1)->m_rect);
20282
20283 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
20284 return resultobj;
20285 fail:
20286 return NULL;
20287 }
20288
20289
20290 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
20291 PyObject *obj;
20292 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20293 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
20294 Py_INCREF(obj);
20295 return Py_BuildValue((char *)"");
20296 }
20297 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20298 PyObject *resultobj = NULL;
20299 wxPoint const &arg1_defvalue = wxDefaultPosition ;
20300 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
20301 int arg2 = (int) 0 ;
20302 wxMoveEvent *result;
20303 wxPoint temp1 ;
20304 PyObject * obj0 = 0 ;
20305 PyObject * obj1 = 0 ;
20306 char *kwnames[] = {
20307 (char *) "pos",(char *) "winid", NULL
20308 };
20309
20310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
20311 if (obj0) {
20312 {
20313 arg1 = &temp1;
20314 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
20315 }
20316 }
20317 if (obj1) {
20318 {
20319 arg2 = static_cast<int >(SWIG_As_int(obj1));
20320 if (SWIG_arg_fail(2)) SWIG_fail;
20321 }
20322 }
20323 {
20324 PyThreadState* __tstate = wxPyBeginAllowThreads();
20325 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
20326
20327 wxPyEndAllowThreads(__tstate);
20328 if (PyErr_Occurred()) SWIG_fail;
20329 }
20330 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
20331 return resultobj;
20332 fail:
20333 return NULL;
20334 }
20335
20336
20337 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20338 PyObject *resultobj = NULL;
20339 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20340 wxPoint result;
20341 PyObject * obj0 = 0 ;
20342 char *kwnames[] = {
20343 (char *) "self", NULL
20344 };
20345
20346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
20347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20348 if (SWIG_arg_fail(1)) SWIG_fail;
20349 {
20350 PyThreadState* __tstate = wxPyBeginAllowThreads();
20351 result = ((wxMoveEvent const *)arg1)->GetPosition();
20352
20353 wxPyEndAllowThreads(__tstate);
20354 if (PyErr_Occurred()) SWIG_fail;
20355 }
20356 {
20357 wxPoint * resultptr;
20358 resultptr = new wxPoint(static_cast<wxPoint & >(result));
20359 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20360 }
20361 return resultobj;
20362 fail:
20363 return NULL;
20364 }
20365
20366
20367 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20368 PyObject *resultobj = NULL;
20369 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20370 wxRect result;
20371 PyObject * obj0 = 0 ;
20372 char *kwnames[] = {
20373 (char *) "self", NULL
20374 };
20375
20376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
20377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20378 if (SWIG_arg_fail(1)) SWIG_fail;
20379 {
20380 PyThreadState* __tstate = wxPyBeginAllowThreads();
20381 result = ((wxMoveEvent const *)arg1)->GetRect();
20382
20383 wxPyEndAllowThreads(__tstate);
20384 if (PyErr_Occurred()) SWIG_fail;
20385 }
20386 {
20387 wxRect * resultptr;
20388 resultptr = new wxRect(static_cast<wxRect & >(result));
20389 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20390 }
20391 return resultobj;
20392 fail:
20393 return NULL;
20394 }
20395
20396
20397 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20398 PyObject *resultobj = NULL;
20399 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20400 wxRect *arg2 = 0 ;
20401 wxRect temp2 ;
20402 PyObject * obj0 = 0 ;
20403 PyObject * obj1 = 0 ;
20404 char *kwnames[] = {
20405 (char *) "self",(char *) "rect", NULL
20406 };
20407
20408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20410 if (SWIG_arg_fail(1)) SWIG_fail;
20411 {
20412 arg2 = &temp2;
20413 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20414 }
20415 {
20416 PyThreadState* __tstate = wxPyBeginAllowThreads();
20417 (arg1)->SetRect((wxRect const &)*arg2);
20418
20419 wxPyEndAllowThreads(__tstate);
20420 if (PyErr_Occurred()) SWIG_fail;
20421 }
20422 Py_INCREF(Py_None); resultobj = Py_None;
20423 return resultobj;
20424 fail:
20425 return NULL;
20426 }
20427
20428
20429 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20430 PyObject *resultobj = NULL;
20431 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20432 wxPoint *arg2 = 0 ;
20433 wxPoint temp2 ;
20434 PyObject * obj0 = 0 ;
20435 PyObject * obj1 = 0 ;
20436 char *kwnames[] = {
20437 (char *) "self",(char *) "pos", NULL
20438 };
20439
20440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
20441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20442 if (SWIG_arg_fail(1)) SWIG_fail;
20443 {
20444 arg2 = &temp2;
20445 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
20446 }
20447 {
20448 PyThreadState* __tstate = wxPyBeginAllowThreads();
20449 (arg1)->SetPosition((wxPoint const &)*arg2);
20450
20451 wxPyEndAllowThreads(__tstate);
20452 if (PyErr_Occurred()) SWIG_fail;
20453 }
20454 Py_INCREF(Py_None); resultobj = Py_None;
20455 return resultobj;
20456 fail:
20457 return NULL;
20458 }
20459
20460
20461 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
20462 PyObject *obj;
20463 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20464 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
20465 Py_INCREF(obj);
20466 return Py_BuildValue((char *)"");
20467 }
20468 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20469 PyObject *resultobj = NULL;
20470 int arg1 = (int) 0 ;
20471 wxPaintEvent *result;
20472 PyObject * obj0 = 0 ;
20473 char *kwnames[] = {
20474 (char *) "Id", NULL
20475 };
20476
20477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
20478 if (obj0) {
20479 {
20480 arg1 = static_cast<int >(SWIG_As_int(obj0));
20481 if (SWIG_arg_fail(1)) SWIG_fail;
20482 }
20483 }
20484 {
20485 PyThreadState* __tstate = wxPyBeginAllowThreads();
20486 result = (wxPaintEvent *)new wxPaintEvent(arg1);
20487
20488 wxPyEndAllowThreads(__tstate);
20489 if (PyErr_Occurred()) SWIG_fail;
20490 }
20491 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
20492 return resultobj;
20493 fail:
20494 return NULL;
20495 }
20496
20497
20498 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
20499 PyObject *obj;
20500 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20501 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
20502 Py_INCREF(obj);
20503 return Py_BuildValue((char *)"");
20504 }
20505 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20506 PyObject *resultobj = NULL;
20507 int arg1 = (int) 0 ;
20508 wxNcPaintEvent *result;
20509 PyObject * obj0 = 0 ;
20510 char *kwnames[] = {
20511 (char *) "winid", NULL
20512 };
20513
20514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
20515 if (obj0) {
20516 {
20517 arg1 = static_cast<int >(SWIG_As_int(obj0));
20518 if (SWIG_arg_fail(1)) SWIG_fail;
20519 }
20520 }
20521 {
20522 PyThreadState* __tstate = wxPyBeginAllowThreads();
20523 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
20524
20525 wxPyEndAllowThreads(__tstate);
20526 if (PyErr_Occurred()) SWIG_fail;
20527 }
20528 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
20529 return resultobj;
20530 fail:
20531 return NULL;
20532 }
20533
20534
20535 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
20536 PyObject *obj;
20537 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20538 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
20539 Py_INCREF(obj);
20540 return Py_BuildValue((char *)"");
20541 }
20542 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20543 PyObject *resultobj = NULL;
20544 int arg1 = (int) 0 ;
20545 wxDC *arg2 = (wxDC *) NULL ;
20546 wxEraseEvent *result;
20547 PyObject * obj0 = 0 ;
20548 PyObject * obj1 = 0 ;
20549 char *kwnames[] = {
20550 (char *) "Id",(char *) "dc", NULL
20551 };
20552
20553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
20554 if (obj0) {
20555 {
20556 arg1 = static_cast<int >(SWIG_As_int(obj0));
20557 if (SWIG_arg_fail(1)) SWIG_fail;
20558 }
20559 }
20560 if (obj1) {
20561 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20562 if (SWIG_arg_fail(2)) SWIG_fail;
20563 }
20564 {
20565 PyThreadState* __tstate = wxPyBeginAllowThreads();
20566 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
20567
20568 wxPyEndAllowThreads(__tstate);
20569 if (PyErr_Occurred()) SWIG_fail;
20570 }
20571 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
20572 return resultobj;
20573 fail:
20574 return NULL;
20575 }
20576
20577
20578 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
20579 PyObject *resultobj = NULL;
20580 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
20581 wxDC *result;
20582 PyObject * obj0 = 0 ;
20583 char *kwnames[] = {
20584 (char *) "self", NULL
20585 };
20586
20587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
20588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
20589 if (SWIG_arg_fail(1)) SWIG_fail;
20590 {
20591 PyThreadState* __tstate = wxPyBeginAllowThreads();
20592 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
20593
20594 wxPyEndAllowThreads(__tstate);
20595 if (PyErr_Occurred()) SWIG_fail;
20596 }
20597 {
20598 resultobj = wxPyMake_wxObject(result, (bool)0);
20599 }
20600 return resultobj;
20601 fail:
20602 return NULL;
20603 }
20604
20605
20606 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
20607 PyObject *obj;
20608 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20609 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
20610 Py_INCREF(obj);
20611 return Py_BuildValue((char *)"");
20612 }
20613 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20614 PyObject *resultobj = NULL;
20615 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20616 int arg2 = (int) 0 ;
20617 wxFocusEvent *result;
20618 PyObject * obj0 = 0 ;
20619 PyObject * obj1 = 0 ;
20620 char *kwnames[] = {
20621 (char *) "type",(char *) "winid", NULL
20622 };
20623
20624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
20625 if (obj0) {
20626 {
20627 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20628 if (SWIG_arg_fail(1)) SWIG_fail;
20629 }
20630 }
20631 if (obj1) {
20632 {
20633 arg2 = static_cast<int >(SWIG_As_int(obj1));
20634 if (SWIG_arg_fail(2)) SWIG_fail;
20635 }
20636 }
20637 {
20638 PyThreadState* __tstate = wxPyBeginAllowThreads();
20639 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
20640
20641 wxPyEndAllowThreads(__tstate);
20642 if (PyErr_Occurred()) SWIG_fail;
20643 }
20644 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
20645 return resultobj;
20646 fail:
20647 return NULL;
20648 }
20649
20650
20651 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20652 PyObject *resultobj = NULL;
20653 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20654 wxWindow *result;
20655 PyObject * obj0 = 0 ;
20656 char *kwnames[] = {
20657 (char *) "self", NULL
20658 };
20659
20660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20662 if (SWIG_arg_fail(1)) SWIG_fail;
20663 {
20664 PyThreadState* __tstate = wxPyBeginAllowThreads();
20665 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
20666
20667 wxPyEndAllowThreads(__tstate);
20668 if (PyErr_Occurred()) SWIG_fail;
20669 }
20670 {
20671 resultobj = wxPyMake_wxObject(result, (bool)0);
20672 }
20673 return resultobj;
20674 fail:
20675 return NULL;
20676 }
20677
20678
20679 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20680 PyObject *resultobj = NULL;
20681 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20682 wxWindow *arg2 = (wxWindow *) 0 ;
20683 PyObject * obj0 = 0 ;
20684 PyObject * obj1 = 0 ;
20685 char *kwnames[] = {
20686 (char *) "self",(char *) "win", NULL
20687 };
20688
20689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
20690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20691 if (SWIG_arg_fail(1)) SWIG_fail;
20692 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20693 if (SWIG_arg_fail(2)) SWIG_fail;
20694 {
20695 PyThreadState* __tstate = wxPyBeginAllowThreads();
20696 (arg1)->SetWindow(arg2);
20697
20698 wxPyEndAllowThreads(__tstate);
20699 if (PyErr_Occurred()) SWIG_fail;
20700 }
20701 Py_INCREF(Py_None); resultobj = Py_None;
20702 return resultobj;
20703 fail:
20704 return NULL;
20705 }
20706
20707
20708 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
20709 PyObject *obj;
20710 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20711 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
20712 Py_INCREF(obj);
20713 return Py_BuildValue((char *)"");
20714 }
20715 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20716 PyObject *resultobj = NULL;
20717 wxWindow *arg1 = (wxWindow *) NULL ;
20718 wxChildFocusEvent *result;
20719 PyObject * obj0 = 0 ;
20720 char *kwnames[] = {
20721 (char *) "win", NULL
20722 };
20723
20724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
20725 if (obj0) {
20726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20727 if (SWIG_arg_fail(1)) SWIG_fail;
20728 }
20729 {
20730 PyThreadState* __tstate = wxPyBeginAllowThreads();
20731 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
20732
20733 wxPyEndAllowThreads(__tstate);
20734 if (PyErr_Occurred()) SWIG_fail;
20735 }
20736 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
20737 return resultobj;
20738 fail:
20739 return NULL;
20740 }
20741
20742
20743 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20744 PyObject *resultobj = NULL;
20745 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
20746 wxWindow *result;
20747 PyObject * obj0 = 0 ;
20748 char *kwnames[] = {
20749 (char *) "self", NULL
20750 };
20751
20752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20754 if (SWIG_arg_fail(1)) SWIG_fail;
20755 {
20756 PyThreadState* __tstate = wxPyBeginAllowThreads();
20757 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
20758
20759 wxPyEndAllowThreads(__tstate);
20760 if (PyErr_Occurred()) SWIG_fail;
20761 }
20762 {
20763 resultobj = wxPyMake_wxObject(result, (bool)0);
20764 }
20765 return resultobj;
20766 fail:
20767 return NULL;
20768 }
20769
20770
20771 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
20772 PyObject *obj;
20773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20774 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
20775 Py_INCREF(obj);
20776 return Py_BuildValue((char *)"");
20777 }
20778 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20779 PyObject *resultobj = NULL;
20780 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20781 bool arg2 = (bool) true ;
20782 int arg3 = (int) 0 ;
20783 wxActivateEvent *result;
20784 PyObject * obj0 = 0 ;
20785 PyObject * obj1 = 0 ;
20786 PyObject * obj2 = 0 ;
20787 char *kwnames[] = {
20788 (char *) "type",(char *) "active",(char *) "Id", NULL
20789 };
20790
20791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20792 if (obj0) {
20793 {
20794 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20795 if (SWIG_arg_fail(1)) SWIG_fail;
20796 }
20797 }
20798 if (obj1) {
20799 {
20800 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
20801 if (SWIG_arg_fail(2)) SWIG_fail;
20802 }
20803 }
20804 if (obj2) {
20805 {
20806 arg3 = static_cast<int >(SWIG_As_int(obj2));
20807 if (SWIG_arg_fail(3)) SWIG_fail;
20808 }
20809 }
20810 {
20811 PyThreadState* __tstate = wxPyBeginAllowThreads();
20812 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20813
20814 wxPyEndAllowThreads(__tstate);
20815 if (PyErr_Occurred()) SWIG_fail;
20816 }
20817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20818 return resultobj;
20819 fail:
20820 return NULL;
20821 }
20822
20823
20824 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20825 PyObject *resultobj = NULL;
20826 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20827 bool result;
20828 PyObject * obj0 = 0 ;
20829 char *kwnames[] = {
20830 (char *) "self", NULL
20831 };
20832
20833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20835 if (SWIG_arg_fail(1)) SWIG_fail;
20836 {
20837 PyThreadState* __tstate = wxPyBeginAllowThreads();
20838 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20839
20840 wxPyEndAllowThreads(__tstate);
20841 if (PyErr_Occurred()) SWIG_fail;
20842 }
20843 {
20844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20845 }
20846 return resultobj;
20847 fail:
20848 return NULL;
20849 }
20850
20851
20852 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20853 PyObject *obj;
20854 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20855 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20856 Py_INCREF(obj);
20857 return Py_BuildValue((char *)"");
20858 }
20859 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20860 PyObject *resultobj = NULL;
20861 int arg1 = (int) 0 ;
20862 wxInitDialogEvent *result;
20863 PyObject * obj0 = 0 ;
20864 char *kwnames[] = {
20865 (char *) "Id", NULL
20866 };
20867
20868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20869 if (obj0) {
20870 {
20871 arg1 = static_cast<int >(SWIG_As_int(obj0));
20872 if (SWIG_arg_fail(1)) SWIG_fail;
20873 }
20874 }
20875 {
20876 PyThreadState* __tstate = wxPyBeginAllowThreads();
20877 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20878
20879 wxPyEndAllowThreads(__tstate);
20880 if (PyErr_Occurred()) SWIG_fail;
20881 }
20882 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20883 return resultobj;
20884 fail:
20885 return NULL;
20886 }
20887
20888
20889 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20890 PyObject *obj;
20891 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20892 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20893 Py_INCREF(obj);
20894 return Py_BuildValue((char *)"");
20895 }
20896 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20897 PyObject *resultobj = NULL;
20898 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20899 int arg2 = (int) 0 ;
20900 wxMenu *arg3 = (wxMenu *) NULL ;
20901 wxMenuEvent *result;
20902 PyObject * obj0 = 0 ;
20903 PyObject * obj1 = 0 ;
20904 PyObject * obj2 = 0 ;
20905 char *kwnames[] = {
20906 (char *) "type",(char *) "winid",(char *) "menu", NULL
20907 };
20908
20909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20910 if (obj0) {
20911 {
20912 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20913 if (SWIG_arg_fail(1)) SWIG_fail;
20914 }
20915 }
20916 if (obj1) {
20917 {
20918 arg2 = static_cast<int >(SWIG_As_int(obj1));
20919 if (SWIG_arg_fail(2)) SWIG_fail;
20920 }
20921 }
20922 if (obj2) {
20923 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20924 if (SWIG_arg_fail(3)) SWIG_fail;
20925 }
20926 {
20927 PyThreadState* __tstate = wxPyBeginAllowThreads();
20928 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20929
20930 wxPyEndAllowThreads(__tstate);
20931 if (PyErr_Occurred()) SWIG_fail;
20932 }
20933 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20934 return resultobj;
20935 fail:
20936 return NULL;
20937 }
20938
20939
20940 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20941 PyObject *resultobj = NULL;
20942 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20943 int result;
20944 PyObject * obj0 = 0 ;
20945 char *kwnames[] = {
20946 (char *) "self", NULL
20947 };
20948
20949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20951 if (SWIG_arg_fail(1)) SWIG_fail;
20952 {
20953 PyThreadState* __tstate = wxPyBeginAllowThreads();
20954 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20955
20956 wxPyEndAllowThreads(__tstate);
20957 if (PyErr_Occurred()) SWIG_fail;
20958 }
20959 {
20960 resultobj = SWIG_From_int(static_cast<int >(result));
20961 }
20962 return resultobj;
20963 fail:
20964 return NULL;
20965 }
20966
20967
20968 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20969 PyObject *resultobj = NULL;
20970 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20971 bool result;
20972 PyObject * obj0 = 0 ;
20973 char *kwnames[] = {
20974 (char *) "self", NULL
20975 };
20976
20977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20979 if (SWIG_arg_fail(1)) SWIG_fail;
20980 {
20981 PyThreadState* __tstate = wxPyBeginAllowThreads();
20982 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20983
20984 wxPyEndAllowThreads(__tstate);
20985 if (PyErr_Occurred()) SWIG_fail;
20986 }
20987 {
20988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20989 }
20990 return resultobj;
20991 fail:
20992 return NULL;
20993 }
20994
20995
20996 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20997 PyObject *resultobj = NULL;
20998 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20999 wxMenu *result;
21000 PyObject * obj0 = 0 ;
21001 char *kwnames[] = {
21002 (char *) "self", NULL
21003 };
21004
21005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
21006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21007 if (SWIG_arg_fail(1)) SWIG_fail;
21008 {
21009 PyThreadState* __tstate = wxPyBeginAllowThreads();
21010 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
21011
21012 wxPyEndAllowThreads(__tstate);
21013 if (PyErr_Occurred()) SWIG_fail;
21014 }
21015 {
21016 resultobj = wxPyMake_wxObject(result, (bool)0);
21017 }
21018 return resultobj;
21019 fail:
21020 return NULL;
21021 }
21022
21023
21024 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
21025 PyObject *obj;
21026 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21027 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
21028 Py_INCREF(obj);
21029 return Py_BuildValue((char *)"");
21030 }
21031 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21032 PyObject *resultobj = NULL;
21033 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21034 int arg2 = (int) 0 ;
21035 wxCloseEvent *result;
21036 PyObject * obj0 = 0 ;
21037 PyObject * obj1 = 0 ;
21038 char *kwnames[] = {
21039 (char *) "type",(char *) "winid", NULL
21040 };
21041
21042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
21043 if (obj0) {
21044 {
21045 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
21046 if (SWIG_arg_fail(1)) SWIG_fail;
21047 }
21048 }
21049 if (obj1) {
21050 {
21051 arg2 = static_cast<int >(SWIG_As_int(obj1));
21052 if (SWIG_arg_fail(2)) SWIG_fail;
21053 }
21054 }
21055 {
21056 PyThreadState* __tstate = wxPyBeginAllowThreads();
21057 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
21058
21059 wxPyEndAllowThreads(__tstate);
21060 if (PyErr_Occurred()) SWIG_fail;
21061 }
21062 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
21063 return resultobj;
21064 fail:
21065 return NULL;
21066 }
21067
21068
21069 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
21070 PyObject *resultobj = NULL;
21071 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21072 bool arg2 ;
21073 PyObject * obj0 = 0 ;
21074 PyObject * obj1 = 0 ;
21075 char *kwnames[] = {
21076 (char *) "self",(char *) "logOff", NULL
21077 };
21078
21079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
21080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21081 if (SWIG_arg_fail(1)) SWIG_fail;
21082 {
21083 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21084 if (SWIG_arg_fail(2)) SWIG_fail;
21085 }
21086 {
21087 PyThreadState* __tstate = wxPyBeginAllowThreads();
21088 (arg1)->SetLoggingOff(arg2);
21089
21090 wxPyEndAllowThreads(__tstate);
21091 if (PyErr_Occurred()) SWIG_fail;
21092 }
21093 Py_INCREF(Py_None); resultobj = Py_None;
21094 return resultobj;
21095 fail:
21096 return NULL;
21097 }
21098
21099
21100 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
21101 PyObject *resultobj = NULL;
21102 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21103 bool result;
21104 PyObject * obj0 = 0 ;
21105 char *kwnames[] = {
21106 (char *) "self", NULL
21107 };
21108
21109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
21110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21111 if (SWIG_arg_fail(1)) SWIG_fail;
21112 {
21113 PyThreadState* __tstate = wxPyBeginAllowThreads();
21114 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
21115
21116 wxPyEndAllowThreads(__tstate);
21117 if (PyErr_Occurred()) SWIG_fail;
21118 }
21119 {
21120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21121 }
21122 return resultobj;
21123 fail:
21124 return NULL;
21125 }
21126
21127
21128 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
21129 PyObject *resultobj = NULL;
21130 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21131 bool arg2 = (bool) true ;
21132 PyObject * obj0 = 0 ;
21133 PyObject * obj1 = 0 ;
21134 char *kwnames[] = {
21135 (char *) "self",(char *) "veto", NULL
21136 };
21137
21138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
21139 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21140 if (SWIG_arg_fail(1)) SWIG_fail;
21141 if (obj1) {
21142 {
21143 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21144 if (SWIG_arg_fail(2)) SWIG_fail;
21145 }
21146 }
21147 {
21148 PyThreadState* __tstate = wxPyBeginAllowThreads();
21149 (arg1)->Veto(arg2);
21150
21151 wxPyEndAllowThreads(__tstate);
21152 if (PyErr_Occurred()) SWIG_fail;
21153 }
21154 Py_INCREF(Py_None); resultobj = Py_None;
21155 return resultobj;
21156 fail:
21157 return NULL;
21158 }
21159
21160
21161 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21162 PyObject *resultobj = NULL;
21163 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21164 bool result;
21165 PyObject * obj0 = 0 ;
21166 char *kwnames[] = {
21167 (char *) "self", NULL
21168 };
21169
21170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
21171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21172 if (SWIG_arg_fail(1)) SWIG_fail;
21173 {
21174 PyThreadState* __tstate = wxPyBeginAllowThreads();
21175 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
21176
21177 wxPyEndAllowThreads(__tstate);
21178 if (PyErr_Occurred()) SWIG_fail;
21179 }
21180 {
21181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21182 }
21183 return resultobj;
21184 fail:
21185 return NULL;
21186 }
21187
21188
21189 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21190 PyObject *resultobj = NULL;
21191 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21192 bool arg2 ;
21193 PyObject * obj0 = 0 ;
21194 PyObject * obj1 = 0 ;
21195 char *kwnames[] = {
21196 (char *) "self",(char *) "canVeto", NULL
21197 };
21198
21199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
21200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21201 if (SWIG_arg_fail(1)) SWIG_fail;
21202 {
21203 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21204 if (SWIG_arg_fail(2)) SWIG_fail;
21205 }
21206 {
21207 PyThreadState* __tstate = wxPyBeginAllowThreads();
21208 (arg1)->SetCanVeto(arg2);
21209
21210 wxPyEndAllowThreads(__tstate);
21211 if (PyErr_Occurred()) SWIG_fail;
21212 }
21213 Py_INCREF(Py_None); resultobj = Py_None;
21214 return resultobj;
21215 fail:
21216 return NULL;
21217 }
21218
21219
21220 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21221 PyObject *resultobj = NULL;
21222 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21223 bool result;
21224 PyObject * obj0 = 0 ;
21225 char *kwnames[] = {
21226 (char *) "self", NULL
21227 };
21228
21229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
21230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21231 if (SWIG_arg_fail(1)) SWIG_fail;
21232 {
21233 PyThreadState* __tstate = wxPyBeginAllowThreads();
21234 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
21235
21236 wxPyEndAllowThreads(__tstate);
21237 if (PyErr_Occurred()) SWIG_fail;
21238 }
21239 {
21240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21241 }
21242 return resultobj;
21243 fail:
21244 return NULL;
21245 }
21246
21247
21248 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
21249 PyObject *obj;
21250 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21251 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
21252 Py_INCREF(obj);
21253 return Py_BuildValue((char *)"");
21254 }
21255 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21256 PyObject *resultobj = NULL;
21257 int arg1 = (int) 0 ;
21258 bool arg2 = (bool) false ;
21259 wxShowEvent *result;
21260 PyObject * obj0 = 0 ;
21261 PyObject * obj1 = 0 ;
21262 char *kwnames[] = {
21263 (char *) "winid",(char *) "show", NULL
21264 };
21265
21266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
21267 if (obj0) {
21268 {
21269 arg1 = static_cast<int >(SWIG_As_int(obj0));
21270 if (SWIG_arg_fail(1)) SWIG_fail;
21271 }
21272 }
21273 if (obj1) {
21274 {
21275 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21276 if (SWIG_arg_fail(2)) SWIG_fail;
21277 }
21278 }
21279 {
21280 PyThreadState* __tstate = wxPyBeginAllowThreads();
21281 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
21282
21283 wxPyEndAllowThreads(__tstate);
21284 if (PyErr_Occurred()) SWIG_fail;
21285 }
21286 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
21287 return resultobj;
21288 fail:
21289 return NULL;
21290 }
21291
21292
21293 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21294 PyObject *resultobj = NULL;
21295 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21296 bool arg2 ;
21297 PyObject * obj0 = 0 ;
21298 PyObject * obj1 = 0 ;
21299 char *kwnames[] = {
21300 (char *) "self",(char *) "show", NULL
21301 };
21302
21303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
21304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21305 if (SWIG_arg_fail(1)) SWIG_fail;
21306 {
21307 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21308 if (SWIG_arg_fail(2)) SWIG_fail;
21309 }
21310 {
21311 PyThreadState* __tstate = wxPyBeginAllowThreads();
21312 (arg1)->SetShow(arg2);
21313
21314 wxPyEndAllowThreads(__tstate);
21315 if (PyErr_Occurred()) SWIG_fail;
21316 }
21317 Py_INCREF(Py_None); resultobj = Py_None;
21318 return resultobj;
21319 fail:
21320 return NULL;
21321 }
21322
21323
21324 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21325 PyObject *resultobj = NULL;
21326 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21327 bool result;
21328 PyObject * obj0 = 0 ;
21329 char *kwnames[] = {
21330 (char *) "self", NULL
21331 };
21332
21333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
21334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21335 if (SWIG_arg_fail(1)) SWIG_fail;
21336 {
21337 PyThreadState* __tstate = wxPyBeginAllowThreads();
21338 result = (bool)((wxShowEvent const *)arg1)->GetShow();
21339
21340 wxPyEndAllowThreads(__tstate);
21341 if (PyErr_Occurred()) SWIG_fail;
21342 }
21343 {
21344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21345 }
21346 return resultobj;
21347 fail:
21348 return NULL;
21349 }
21350
21351
21352 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
21353 PyObject *obj;
21354 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21355 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
21356 Py_INCREF(obj);
21357 return Py_BuildValue((char *)"");
21358 }
21359 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21360 PyObject *resultobj = NULL;
21361 int arg1 = (int) 0 ;
21362 bool arg2 = (bool) true ;
21363 wxIconizeEvent *result;
21364 PyObject * obj0 = 0 ;
21365 PyObject * obj1 = 0 ;
21366 char *kwnames[] = {
21367 (char *) "id",(char *) "iconized", NULL
21368 };
21369
21370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
21371 if (obj0) {
21372 {
21373 arg1 = static_cast<int >(SWIG_As_int(obj0));
21374 if (SWIG_arg_fail(1)) SWIG_fail;
21375 }
21376 }
21377 if (obj1) {
21378 {
21379 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21380 if (SWIG_arg_fail(2)) SWIG_fail;
21381 }
21382 }
21383 {
21384 PyThreadState* __tstate = wxPyBeginAllowThreads();
21385 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
21386
21387 wxPyEndAllowThreads(__tstate);
21388 if (PyErr_Occurred()) SWIG_fail;
21389 }
21390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
21391 return resultobj;
21392 fail:
21393 return NULL;
21394 }
21395
21396
21397 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
21398 PyObject *resultobj = NULL;
21399 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
21400 bool result;
21401 PyObject * obj0 = 0 ;
21402 char *kwnames[] = {
21403 (char *) "self", NULL
21404 };
21405
21406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
21407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
21408 if (SWIG_arg_fail(1)) SWIG_fail;
21409 {
21410 PyThreadState* __tstate = wxPyBeginAllowThreads();
21411 result = (bool)(arg1)->Iconized();
21412
21413 wxPyEndAllowThreads(__tstate);
21414 if (PyErr_Occurred()) SWIG_fail;
21415 }
21416 {
21417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21418 }
21419 return resultobj;
21420 fail:
21421 return NULL;
21422 }
21423
21424
21425 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
21426 PyObject *obj;
21427 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21428 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
21429 Py_INCREF(obj);
21430 return Py_BuildValue((char *)"");
21431 }
21432 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21433 PyObject *resultobj = NULL;
21434 int arg1 = (int) 0 ;
21435 wxMaximizeEvent *result;
21436 PyObject * obj0 = 0 ;
21437 char *kwnames[] = {
21438 (char *) "id", NULL
21439 };
21440
21441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
21442 if (obj0) {
21443 {
21444 arg1 = static_cast<int >(SWIG_As_int(obj0));
21445 if (SWIG_arg_fail(1)) SWIG_fail;
21446 }
21447 }
21448 {
21449 PyThreadState* __tstate = wxPyBeginAllowThreads();
21450 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
21451
21452 wxPyEndAllowThreads(__tstate);
21453 if (PyErr_Occurred()) SWIG_fail;
21454 }
21455 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
21456 return resultobj;
21457 fail:
21458 return NULL;
21459 }
21460
21461
21462 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
21463 PyObject *obj;
21464 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21465 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
21466 Py_INCREF(obj);
21467 return Py_BuildValue((char *)"");
21468 }
21469 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21470 PyObject *resultobj = NULL;
21471 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21472 wxPoint result;
21473 PyObject * obj0 = 0 ;
21474 char *kwnames[] = {
21475 (char *) "self", NULL
21476 };
21477
21478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
21479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21480 if (SWIG_arg_fail(1)) SWIG_fail;
21481 {
21482 PyThreadState* __tstate = wxPyBeginAllowThreads();
21483 result = (arg1)->GetPosition();
21484
21485 wxPyEndAllowThreads(__tstate);
21486 if (PyErr_Occurred()) SWIG_fail;
21487 }
21488 {
21489 wxPoint * resultptr;
21490 resultptr = new wxPoint(static_cast<wxPoint & >(result));
21491 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
21492 }
21493 return resultobj;
21494 fail:
21495 return NULL;
21496 }
21497
21498
21499 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21500 PyObject *resultobj = NULL;
21501 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21502 int result;
21503 PyObject * obj0 = 0 ;
21504 char *kwnames[] = {
21505 (char *) "self", NULL
21506 };
21507
21508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
21509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21510 if (SWIG_arg_fail(1)) SWIG_fail;
21511 {
21512 PyThreadState* __tstate = wxPyBeginAllowThreads();
21513 result = (int)(arg1)->GetNumberOfFiles();
21514
21515 wxPyEndAllowThreads(__tstate);
21516 if (PyErr_Occurred()) SWIG_fail;
21517 }
21518 {
21519 resultobj = SWIG_From_int(static_cast<int >(result));
21520 }
21521 return resultobj;
21522 fail:
21523 return NULL;
21524 }
21525
21526
21527 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21528 PyObject *resultobj = NULL;
21529 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21530 PyObject *result;
21531 PyObject * obj0 = 0 ;
21532 char *kwnames[] = {
21533 (char *) "self", NULL
21534 };
21535
21536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
21537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21538 if (SWIG_arg_fail(1)) SWIG_fail;
21539 {
21540 PyThreadState* __tstate = wxPyBeginAllowThreads();
21541 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
21542
21543 wxPyEndAllowThreads(__tstate);
21544 if (PyErr_Occurred()) SWIG_fail;
21545 }
21546 resultobj = result;
21547 return resultobj;
21548 fail:
21549 return NULL;
21550 }
21551
21552
21553 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
21554 PyObject *obj;
21555 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21556 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
21557 Py_INCREF(obj);
21558 return Py_BuildValue((char *)"");
21559 }
21560 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21561 PyObject *resultobj = NULL;
21562 int arg1 = (int) 0 ;
21563 wxUpdateUIEvent *result;
21564 PyObject * obj0 = 0 ;
21565 char *kwnames[] = {
21566 (char *) "commandId", NULL
21567 };
21568
21569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
21570 if (obj0) {
21571 {
21572 arg1 = static_cast<int >(SWIG_As_int(obj0));
21573 if (SWIG_arg_fail(1)) SWIG_fail;
21574 }
21575 }
21576 {
21577 PyThreadState* __tstate = wxPyBeginAllowThreads();
21578 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
21579
21580 wxPyEndAllowThreads(__tstate);
21581 if (PyErr_Occurred()) SWIG_fail;
21582 }
21583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
21584 return resultobj;
21585 fail:
21586 return NULL;
21587 }
21588
21589
21590 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21591 PyObject *resultobj = NULL;
21592 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21593 bool result;
21594 PyObject * obj0 = 0 ;
21595 char *kwnames[] = {
21596 (char *) "self", NULL
21597 };
21598
21599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
21600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21601 if (SWIG_arg_fail(1)) SWIG_fail;
21602 {
21603 PyThreadState* __tstate = wxPyBeginAllowThreads();
21604 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
21605
21606 wxPyEndAllowThreads(__tstate);
21607 if (PyErr_Occurred()) SWIG_fail;
21608 }
21609 {
21610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21611 }
21612 return resultobj;
21613 fail:
21614 return NULL;
21615 }
21616
21617
21618 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21619 PyObject *resultobj = NULL;
21620 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21621 bool result;
21622 PyObject * obj0 = 0 ;
21623 char *kwnames[] = {
21624 (char *) "self", NULL
21625 };
21626
21627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
21628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21629 if (SWIG_arg_fail(1)) SWIG_fail;
21630 {
21631 PyThreadState* __tstate = wxPyBeginAllowThreads();
21632 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
21633
21634 wxPyEndAllowThreads(__tstate);
21635 if (PyErr_Occurred()) SWIG_fail;
21636 }
21637 {
21638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21639 }
21640 return resultobj;
21641 fail:
21642 return NULL;
21643 }
21644
21645
21646 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
21647 PyObject *resultobj = NULL;
21648 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21649 wxString result;
21650 PyObject * obj0 = 0 ;
21651 char *kwnames[] = {
21652 (char *) "self", NULL
21653 };
21654
21655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
21656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21657 if (SWIG_arg_fail(1)) SWIG_fail;
21658 {
21659 PyThreadState* __tstate = wxPyBeginAllowThreads();
21660 result = ((wxUpdateUIEvent const *)arg1)->GetText();
21661
21662 wxPyEndAllowThreads(__tstate);
21663 if (PyErr_Occurred()) SWIG_fail;
21664 }
21665 {
21666 #if wxUSE_UNICODE
21667 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21668 #else
21669 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21670 #endif
21671 }
21672 return resultobj;
21673 fail:
21674 return NULL;
21675 }
21676
21677
21678 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
21679 PyObject *resultobj = NULL;
21680 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21681 bool result;
21682 PyObject * obj0 = 0 ;
21683 char *kwnames[] = {
21684 (char *) "self", NULL
21685 };
21686
21687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
21688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21689 if (SWIG_arg_fail(1)) SWIG_fail;
21690 {
21691 PyThreadState* __tstate = wxPyBeginAllowThreads();
21692 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
21693
21694 wxPyEndAllowThreads(__tstate);
21695 if (PyErr_Occurred()) SWIG_fail;
21696 }
21697 {
21698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21699 }
21700 return resultobj;
21701 fail:
21702 return NULL;
21703 }
21704
21705
21706 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21707 PyObject *resultobj = NULL;
21708 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21709 bool result;
21710 PyObject * obj0 = 0 ;
21711 char *kwnames[] = {
21712 (char *) "self", NULL
21713 };
21714
21715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
21716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21717 if (SWIG_arg_fail(1)) SWIG_fail;
21718 {
21719 PyThreadState* __tstate = wxPyBeginAllowThreads();
21720 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
21721
21722 wxPyEndAllowThreads(__tstate);
21723 if (PyErr_Occurred()) SWIG_fail;
21724 }
21725 {
21726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21727 }
21728 return resultobj;
21729 fail:
21730 return NULL;
21731 }
21732
21733
21734 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21735 PyObject *resultobj = NULL;
21736 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21737 bool result;
21738 PyObject * obj0 = 0 ;
21739 char *kwnames[] = {
21740 (char *) "self", NULL
21741 };
21742
21743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
21744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21745 if (SWIG_arg_fail(1)) SWIG_fail;
21746 {
21747 PyThreadState* __tstate = wxPyBeginAllowThreads();
21748 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
21749
21750 wxPyEndAllowThreads(__tstate);
21751 if (PyErr_Occurred()) SWIG_fail;
21752 }
21753 {
21754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21755 }
21756 return resultobj;
21757 fail:
21758 return NULL;
21759 }
21760
21761
21762 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
21763 PyObject *resultobj = NULL;
21764 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21765 bool arg2 ;
21766 PyObject * obj0 = 0 ;
21767 PyObject * obj1 = 0 ;
21768 char *kwnames[] = {
21769 (char *) "self",(char *) "check", NULL
21770 };
21771
21772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
21773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21774 if (SWIG_arg_fail(1)) SWIG_fail;
21775 {
21776 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21777 if (SWIG_arg_fail(2)) SWIG_fail;
21778 }
21779 {
21780 PyThreadState* __tstate = wxPyBeginAllowThreads();
21781 (arg1)->Check(arg2);
21782
21783 wxPyEndAllowThreads(__tstate);
21784 if (PyErr_Occurred()) SWIG_fail;
21785 }
21786 Py_INCREF(Py_None); resultobj = Py_None;
21787 return resultobj;
21788 fail:
21789 return NULL;
21790 }
21791
21792
21793 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21794 PyObject *resultobj = NULL;
21795 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21796 bool arg2 ;
21797 PyObject * obj0 = 0 ;
21798 PyObject * obj1 = 0 ;
21799 char *kwnames[] = {
21800 (char *) "self",(char *) "enable", NULL
21801 };
21802
21803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21805 if (SWIG_arg_fail(1)) SWIG_fail;
21806 {
21807 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21808 if (SWIG_arg_fail(2)) SWIG_fail;
21809 }
21810 {
21811 PyThreadState* __tstate = wxPyBeginAllowThreads();
21812 (arg1)->Enable(arg2);
21813
21814 wxPyEndAllowThreads(__tstate);
21815 if (PyErr_Occurred()) SWIG_fail;
21816 }
21817 Py_INCREF(Py_None); resultobj = Py_None;
21818 return resultobj;
21819 fail:
21820 return NULL;
21821 }
21822
21823
21824 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21825 PyObject *resultobj = NULL;
21826 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21827 wxString *arg2 = 0 ;
21828 bool temp2 = false ;
21829 PyObject * obj0 = 0 ;
21830 PyObject * obj1 = 0 ;
21831 char *kwnames[] = {
21832 (char *) "self",(char *) "text", NULL
21833 };
21834
21835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21837 if (SWIG_arg_fail(1)) SWIG_fail;
21838 {
21839 arg2 = wxString_in_helper(obj1);
21840 if (arg2 == NULL) SWIG_fail;
21841 temp2 = true;
21842 }
21843 {
21844 PyThreadState* __tstate = wxPyBeginAllowThreads();
21845 (arg1)->SetText((wxString const &)*arg2);
21846
21847 wxPyEndAllowThreads(__tstate);
21848 if (PyErr_Occurred()) SWIG_fail;
21849 }
21850 Py_INCREF(Py_None); resultobj = Py_None;
21851 {
21852 if (temp2)
21853 delete arg2;
21854 }
21855 return resultobj;
21856 fail:
21857 {
21858 if (temp2)
21859 delete arg2;
21860 }
21861 return NULL;
21862 }
21863
21864
21865 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21866 PyObject *resultobj = NULL;
21867 long arg1 ;
21868 PyObject * obj0 = 0 ;
21869 char *kwnames[] = {
21870 (char *) "updateInterval", NULL
21871 };
21872
21873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21874 {
21875 arg1 = static_cast<long >(SWIG_As_long(obj0));
21876 if (SWIG_arg_fail(1)) SWIG_fail;
21877 }
21878 {
21879 PyThreadState* __tstate = wxPyBeginAllowThreads();
21880 wxUpdateUIEvent::SetUpdateInterval(arg1);
21881
21882 wxPyEndAllowThreads(__tstate);
21883 if (PyErr_Occurred()) SWIG_fail;
21884 }
21885 Py_INCREF(Py_None); resultobj = Py_None;
21886 return resultobj;
21887 fail:
21888 return NULL;
21889 }
21890
21891
21892 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21893 PyObject *resultobj = NULL;
21894 long result;
21895 char *kwnames[] = {
21896 NULL
21897 };
21898
21899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21900 {
21901 PyThreadState* __tstate = wxPyBeginAllowThreads();
21902 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21903
21904 wxPyEndAllowThreads(__tstate);
21905 if (PyErr_Occurred()) SWIG_fail;
21906 }
21907 {
21908 resultobj = SWIG_From_long(static_cast<long >(result));
21909 }
21910 return resultobj;
21911 fail:
21912 return NULL;
21913 }
21914
21915
21916 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21917 PyObject *resultobj = NULL;
21918 wxWindow *arg1 = (wxWindow *) 0 ;
21919 bool result;
21920 PyObject * obj0 = 0 ;
21921 char *kwnames[] = {
21922 (char *) "win", NULL
21923 };
21924
21925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21927 if (SWIG_arg_fail(1)) SWIG_fail;
21928 {
21929 PyThreadState* __tstate = wxPyBeginAllowThreads();
21930 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21931
21932 wxPyEndAllowThreads(__tstate);
21933 if (PyErr_Occurred()) SWIG_fail;
21934 }
21935 {
21936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21937 }
21938 return resultobj;
21939 fail:
21940 return NULL;
21941 }
21942
21943
21944 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21945 PyObject *resultobj = NULL;
21946 char *kwnames[] = {
21947 NULL
21948 };
21949
21950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21951 {
21952 PyThreadState* __tstate = wxPyBeginAllowThreads();
21953 wxUpdateUIEvent::ResetUpdateTime();
21954
21955 wxPyEndAllowThreads(__tstate);
21956 if (PyErr_Occurred()) SWIG_fail;
21957 }
21958 Py_INCREF(Py_None); resultobj = Py_None;
21959 return resultobj;
21960 fail:
21961 return NULL;
21962 }
21963
21964
21965 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21966 PyObject *resultobj = NULL;
21967 wxUpdateUIMode arg1 ;
21968 PyObject * obj0 = 0 ;
21969 char *kwnames[] = {
21970 (char *) "mode", NULL
21971 };
21972
21973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21974 {
21975 arg1 = static_cast<wxUpdateUIMode >(SWIG_As_int(obj0));
21976 if (SWIG_arg_fail(1)) SWIG_fail;
21977 }
21978 {
21979 PyThreadState* __tstate = wxPyBeginAllowThreads();
21980 wxUpdateUIEvent::SetMode(arg1);
21981
21982 wxPyEndAllowThreads(__tstate);
21983 if (PyErr_Occurred()) SWIG_fail;
21984 }
21985 Py_INCREF(Py_None); resultobj = Py_None;
21986 return resultobj;
21987 fail:
21988 return NULL;
21989 }
21990
21991
21992 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21993 PyObject *resultobj = NULL;
21994 wxUpdateUIMode result;
21995 char *kwnames[] = {
21996 NULL
21997 };
21998
21999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
22000 {
22001 PyThreadState* __tstate = wxPyBeginAllowThreads();
22002 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
22003
22004 wxPyEndAllowThreads(__tstate);
22005 if (PyErr_Occurred()) SWIG_fail;
22006 }
22007 resultobj = SWIG_From_int((result));
22008 return resultobj;
22009 fail:
22010 return NULL;
22011 }
22012
22013
22014 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
22015 PyObject *obj;
22016 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22017 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
22018 Py_INCREF(obj);
22019 return Py_BuildValue((char *)"");
22020 }
22021 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22022 PyObject *resultobj = NULL;
22023 wxSysColourChangedEvent *result;
22024 char *kwnames[] = {
22025 NULL
22026 };
22027
22028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
22029 {
22030 PyThreadState* __tstate = wxPyBeginAllowThreads();
22031 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
22032
22033 wxPyEndAllowThreads(__tstate);
22034 if (PyErr_Occurred()) SWIG_fail;
22035 }
22036 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
22037 return resultobj;
22038 fail:
22039 return NULL;
22040 }
22041
22042
22043 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
22044 PyObject *obj;
22045 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22046 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
22047 Py_INCREF(obj);
22048 return Py_BuildValue((char *)"");
22049 }
22050 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22051 PyObject *resultobj = NULL;
22052 int arg1 = (int) 0 ;
22053 wxWindow *arg2 = (wxWindow *) NULL ;
22054 wxMouseCaptureChangedEvent *result;
22055 PyObject * obj0 = 0 ;
22056 PyObject * obj1 = 0 ;
22057 char *kwnames[] = {
22058 (char *) "winid",(char *) "gainedCapture", NULL
22059 };
22060
22061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
22062 if (obj0) {
22063 {
22064 arg1 = static_cast<int >(SWIG_As_int(obj0));
22065 if (SWIG_arg_fail(1)) SWIG_fail;
22066 }
22067 }
22068 if (obj1) {
22069 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22070 if (SWIG_arg_fail(2)) SWIG_fail;
22071 }
22072 {
22073 PyThreadState* __tstate = wxPyBeginAllowThreads();
22074 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
22075
22076 wxPyEndAllowThreads(__tstate);
22077 if (PyErr_Occurred()) SWIG_fail;
22078 }
22079 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
22080 return resultobj;
22081 fail:
22082 return NULL;
22083 }
22084
22085
22086 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22087 PyObject *resultobj = NULL;
22088 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
22089 wxWindow *result;
22090 PyObject * obj0 = 0 ;
22091 char *kwnames[] = {
22092 (char *) "self", NULL
22093 };
22094
22095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
22096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22097 if (SWIG_arg_fail(1)) SWIG_fail;
22098 {
22099 PyThreadState* __tstate = wxPyBeginAllowThreads();
22100 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
22101
22102 wxPyEndAllowThreads(__tstate);
22103 if (PyErr_Occurred()) SWIG_fail;
22104 }
22105 {
22106 resultobj = wxPyMake_wxObject(result, (bool)0);
22107 }
22108 return resultobj;
22109 fail:
22110 return NULL;
22111 }
22112
22113
22114 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
22115 PyObject *obj;
22116 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22117 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
22118 Py_INCREF(obj);
22119 return Py_BuildValue((char *)"");
22120 }
22121 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22122 PyObject *resultobj = NULL;
22123 wxDisplayChangedEvent *result;
22124 char *kwnames[] = {
22125 NULL
22126 };
22127
22128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
22129 {
22130 PyThreadState* __tstate = wxPyBeginAllowThreads();
22131 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
22132
22133 wxPyEndAllowThreads(__tstate);
22134 if (PyErr_Occurred()) SWIG_fail;
22135 }
22136 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
22137 return resultobj;
22138 fail:
22139 return NULL;
22140 }
22141
22142
22143 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
22144 PyObject *obj;
22145 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22146 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
22147 Py_INCREF(obj);
22148 return Py_BuildValue((char *)"");
22149 }
22150 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22151 PyObject *resultobj = NULL;
22152 int arg1 = (int) 0 ;
22153 wxPaletteChangedEvent *result;
22154 PyObject * obj0 = 0 ;
22155 char *kwnames[] = {
22156 (char *) "id", NULL
22157 };
22158
22159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
22160 if (obj0) {
22161 {
22162 arg1 = static_cast<int >(SWIG_As_int(obj0));
22163 if (SWIG_arg_fail(1)) SWIG_fail;
22164 }
22165 }
22166 {
22167 PyThreadState* __tstate = wxPyBeginAllowThreads();
22168 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
22169
22170 wxPyEndAllowThreads(__tstate);
22171 if (PyErr_Occurred()) SWIG_fail;
22172 }
22173 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
22174 return resultobj;
22175 fail:
22176 return NULL;
22177 }
22178
22179
22180 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22181 PyObject *resultobj = NULL;
22182 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22183 wxWindow *arg2 = (wxWindow *) 0 ;
22184 PyObject * obj0 = 0 ;
22185 PyObject * obj1 = 0 ;
22186 char *kwnames[] = {
22187 (char *) "self",(char *) "win", NULL
22188 };
22189
22190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
22191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22192 if (SWIG_arg_fail(1)) SWIG_fail;
22193 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22194 if (SWIG_arg_fail(2)) SWIG_fail;
22195 {
22196 PyThreadState* __tstate = wxPyBeginAllowThreads();
22197 (arg1)->SetChangedWindow(arg2);
22198
22199 wxPyEndAllowThreads(__tstate);
22200 if (PyErr_Occurred()) SWIG_fail;
22201 }
22202 Py_INCREF(Py_None); resultobj = Py_None;
22203 return resultobj;
22204 fail:
22205 return NULL;
22206 }
22207
22208
22209 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22210 PyObject *resultobj = NULL;
22211 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22212 wxWindow *result;
22213 PyObject * obj0 = 0 ;
22214 char *kwnames[] = {
22215 (char *) "self", NULL
22216 };
22217
22218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
22219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22220 if (SWIG_arg_fail(1)) SWIG_fail;
22221 {
22222 PyThreadState* __tstate = wxPyBeginAllowThreads();
22223 result = (wxWindow *)(arg1)->GetChangedWindow();
22224
22225 wxPyEndAllowThreads(__tstate);
22226 if (PyErr_Occurred()) SWIG_fail;
22227 }
22228 {
22229 resultobj = wxPyMake_wxObject(result, (bool)0);
22230 }
22231 return resultobj;
22232 fail:
22233 return NULL;
22234 }
22235
22236
22237 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
22238 PyObject *obj;
22239 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22240 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
22241 Py_INCREF(obj);
22242 return Py_BuildValue((char *)"");
22243 }
22244 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22245 PyObject *resultobj = NULL;
22246 int arg1 = (int) 0 ;
22247 wxQueryNewPaletteEvent *result;
22248 PyObject * obj0 = 0 ;
22249 char *kwnames[] = {
22250 (char *) "winid", NULL
22251 };
22252
22253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
22254 if (obj0) {
22255 {
22256 arg1 = static_cast<int >(SWIG_As_int(obj0));
22257 if (SWIG_arg_fail(1)) SWIG_fail;
22258 }
22259 }
22260 {
22261 PyThreadState* __tstate = wxPyBeginAllowThreads();
22262 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
22263
22264 wxPyEndAllowThreads(__tstate);
22265 if (PyErr_Occurred()) SWIG_fail;
22266 }
22267 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
22268 return resultobj;
22269 fail:
22270 return NULL;
22271 }
22272
22273
22274 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22275 PyObject *resultobj = NULL;
22276 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22277 bool arg2 ;
22278 PyObject * obj0 = 0 ;
22279 PyObject * obj1 = 0 ;
22280 char *kwnames[] = {
22281 (char *) "self",(char *) "realized", NULL
22282 };
22283
22284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
22285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22286 if (SWIG_arg_fail(1)) SWIG_fail;
22287 {
22288 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22289 if (SWIG_arg_fail(2)) SWIG_fail;
22290 }
22291 {
22292 PyThreadState* __tstate = wxPyBeginAllowThreads();
22293 (arg1)->SetPaletteRealized(arg2);
22294
22295 wxPyEndAllowThreads(__tstate);
22296 if (PyErr_Occurred()) SWIG_fail;
22297 }
22298 Py_INCREF(Py_None); resultobj = Py_None;
22299 return resultobj;
22300 fail:
22301 return NULL;
22302 }
22303
22304
22305 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22306 PyObject *resultobj = NULL;
22307 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22308 bool result;
22309 PyObject * obj0 = 0 ;
22310 char *kwnames[] = {
22311 (char *) "self", NULL
22312 };
22313
22314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
22315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22316 if (SWIG_arg_fail(1)) SWIG_fail;
22317 {
22318 PyThreadState* __tstate = wxPyBeginAllowThreads();
22319 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
22320
22321 wxPyEndAllowThreads(__tstate);
22322 if (PyErr_Occurred()) SWIG_fail;
22323 }
22324 {
22325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22326 }
22327 return resultobj;
22328 fail:
22329 return NULL;
22330 }
22331
22332
22333 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
22334 PyObject *obj;
22335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22336 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
22337 Py_INCREF(obj);
22338 return Py_BuildValue((char *)"");
22339 }
22340 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22341 PyObject *resultobj = NULL;
22342 wxNavigationKeyEvent *result;
22343 char *kwnames[] = {
22344 NULL
22345 };
22346
22347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
22348 {
22349 PyThreadState* __tstate = wxPyBeginAllowThreads();
22350 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
22351
22352 wxPyEndAllowThreads(__tstate);
22353 if (PyErr_Occurred()) SWIG_fail;
22354 }
22355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
22356 return resultobj;
22357 fail:
22358 return NULL;
22359 }
22360
22361
22362 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22363 PyObject *resultobj = NULL;
22364 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22365 bool result;
22366 PyObject * obj0 = 0 ;
22367 char *kwnames[] = {
22368 (char *) "self", NULL
22369 };
22370
22371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
22372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22373 if (SWIG_arg_fail(1)) SWIG_fail;
22374 {
22375 PyThreadState* __tstate = wxPyBeginAllowThreads();
22376 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
22377
22378 wxPyEndAllowThreads(__tstate);
22379 if (PyErr_Occurred()) SWIG_fail;
22380 }
22381 {
22382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22383 }
22384 return resultobj;
22385 fail:
22386 return NULL;
22387 }
22388
22389
22390 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22391 PyObject *resultobj = NULL;
22392 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22393 bool arg2 ;
22394 PyObject * obj0 = 0 ;
22395 PyObject * obj1 = 0 ;
22396 char *kwnames[] = {
22397 (char *) "self",(char *) "forward", NULL
22398 };
22399
22400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
22401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22402 if (SWIG_arg_fail(1)) SWIG_fail;
22403 {
22404 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22405 if (SWIG_arg_fail(2)) SWIG_fail;
22406 }
22407 {
22408 PyThreadState* __tstate = wxPyBeginAllowThreads();
22409 (arg1)->SetDirection(arg2);
22410
22411 wxPyEndAllowThreads(__tstate);
22412 if (PyErr_Occurred()) SWIG_fail;
22413 }
22414 Py_INCREF(Py_None); resultobj = Py_None;
22415 return resultobj;
22416 fail:
22417 return NULL;
22418 }
22419
22420
22421 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22422 PyObject *resultobj = NULL;
22423 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22424 bool result;
22425 PyObject * obj0 = 0 ;
22426 char *kwnames[] = {
22427 (char *) "self", NULL
22428 };
22429
22430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
22431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22432 if (SWIG_arg_fail(1)) SWIG_fail;
22433 {
22434 PyThreadState* __tstate = wxPyBeginAllowThreads();
22435 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
22436
22437 wxPyEndAllowThreads(__tstate);
22438 if (PyErr_Occurred()) SWIG_fail;
22439 }
22440 {
22441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22442 }
22443 return resultobj;
22444 fail:
22445 return NULL;
22446 }
22447
22448
22449 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22450 PyObject *resultobj = NULL;
22451 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22452 bool arg2 ;
22453 PyObject * obj0 = 0 ;
22454 PyObject * obj1 = 0 ;
22455 char *kwnames[] = {
22456 (char *) "self",(char *) "ischange", NULL
22457 };
22458
22459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
22460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22461 if (SWIG_arg_fail(1)) SWIG_fail;
22462 {
22463 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22464 if (SWIG_arg_fail(2)) SWIG_fail;
22465 }
22466 {
22467 PyThreadState* __tstate = wxPyBeginAllowThreads();
22468 (arg1)->SetWindowChange(arg2);
22469
22470 wxPyEndAllowThreads(__tstate);
22471 if (PyErr_Occurred()) SWIG_fail;
22472 }
22473 Py_INCREF(Py_None); resultobj = Py_None;
22474 return resultobj;
22475 fail:
22476 return NULL;
22477 }
22478
22479
22480 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22481 PyObject *resultobj = NULL;
22482 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22483 bool result;
22484 PyObject * obj0 = 0 ;
22485 char *kwnames[] = {
22486 (char *) "self", NULL
22487 };
22488
22489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
22490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22491 if (SWIG_arg_fail(1)) SWIG_fail;
22492 {
22493 PyThreadState* __tstate = wxPyBeginAllowThreads();
22494 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
22495
22496 wxPyEndAllowThreads(__tstate);
22497 if (PyErr_Occurred()) SWIG_fail;
22498 }
22499 {
22500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22501 }
22502 return resultobj;
22503 fail:
22504 return NULL;
22505 }
22506
22507
22508 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22509 PyObject *resultobj = NULL;
22510 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22511 bool arg2 ;
22512 PyObject * obj0 = 0 ;
22513 PyObject * obj1 = 0 ;
22514 char *kwnames[] = {
22515 (char *) "self",(char *) "bIs", NULL
22516 };
22517
22518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
22519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22520 if (SWIG_arg_fail(1)) SWIG_fail;
22521 {
22522 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22523 if (SWIG_arg_fail(2)) SWIG_fail;
22524 }
22525 {
22526 PyThreadState* __tstate = wxPyBeginAllowThreads();
22527 (arg1)->SetFromTab(arg2);
22528
22529 wxPyEndAllowThreads(__tstate);
22530 if (PyErr_Occurred()) SWIG_fail;
22531 }
22532 Py_INCREF(Py_None); resultobj = Py_None;
22533 return resultobj;
22534 fail:
22535 return NULL;
22536 }
22537
22538
22539 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
22540 PyObject *resultobj = NULL;
22541 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22542 long arg2 ;
22543 PyObject * obj0 = 0 ;
22544 PyObject * obj1 = 0 ;
22545 char *kwnames[] = {
22546 (char *) "self",(char *) "flags", NULL
22547 };
22548
22549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
22550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22551 if (SWIG_arg_fail(1)) SWIG_fail;
22552 {
22553 arg2 = static_cast<long >(SWIG_As_long(obj1));
22554 if (SWIG_arg_fail(2)) SWIG_fail;
22555 }
22556 {
22557 PyThreadState* __tstate = wxPyBeginAllowThreads();
22558 (arg1)->SetFlags(arg2);
22559
22560 wxPyEndAllowThreads(__tstate);
22561 if (PyErr_Occurred()) SWIG_fail;
22562 }
22563 Py_INCREF(Py_None); resultobj = Py_None;
22564 return resultobj;
22565 fail:
22566 return NULL;
22567 }
22568
22569
22570 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22571 PyObject *resultobj = NULL;
22572 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22573 wxWindow *result;
22574 PyObject * obj0 = 0 ;
22575 char *kwnames[] = {
22576 (char *) "self", NULL
22577 };
22578
22579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
22580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22581 if (SWIG_arg_fail(1)) SWIG_fail;
22582 {
22583 PyThreadState* __tstate = wxPyBeginAllowThreads();
22584 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
22585
22586 wxPyEndAllowThreads(__tstate);
22587 if (PyErr_Occurred()) SWIG_fail;
22588 }
22589 {
22590 resultobj = wxPyMake_wxObject(result, (bool)0);
22591 }
22592 return resultobj;
22593 fail:
22594 return NULL;
22595 }
22596
22597
22598 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22599 PyObject *resultobj = NULL;
22600 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22601 wxWindow *arg2 = (wxWindow *) 0 ;
22602 PyObject * obj0 = 0 ;
22603 PyObject * obj1 = 0 ;
22604 char *kwnames[] = {
22605 (char *) "self",(char *) "win", NULL
22606 };
22607
22608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
22609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22610 if (SWIG_arg_fail(1)) SWIG_fail;
22611 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22612 if (SWIG_arg_fail(2)) SWIG_fail;
22613 {
22614 PyThreadState* __tstate = wxPyBeginAllowThreads();
22615 (arg1)->SetCurrentFocus(arg2);
22616
22617 wxPyEndAllowThreads(__tstate);
22618 if (PyErr_Occurred()) SWIG_fail;
22619 }
22620 Py_INCREF(Py_None); resultobj = Py_None;
22621 return resultobj;
22622 fail:
22623 return NULL;
22624 }
22625
22626
22627 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
22628 PyObject *obj;
22629 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22630 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
22631 Py_INCREF(obj);
22632 return Py_BuildValue((char *)"");
22633 }
22634 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22635 PyObject *resultobj = NULL;
22636 wxWindow *arg1 = (wxWindow *) NULL ;
22637 wxWindowCreateEvent *result;
22638 PyObject * obj0 = 0 ;
22639 char *kwnames[] = {
22640 (char *) "win", NULL
22641 };
22642
22643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
22644 if (obj0) {
22645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22646 if (SWIG_arg_fail(1)) SWIG_fail;
22647 }
22648 {
22649 PyThreadState* __tstate = wxPyBeginAllowThreads();
22650 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
22651
22652 wxPyEndAllowThreads(__tstate);
22653 if (PyErr_Occurred()) SWIG_fail;
22654 }
22655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
22656 return resultobj;
22657 fail:
22658 return NULL;
22659 }
22660
22661
22662 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22663 PyObject *resultobj = NULL;
22664 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
22665 wxWindow *result;
22666 PyObject * obj0 = 0 ;
22667 char *kwnames[] = {
22668 (char *) "self", NULL
22669 };
22670
22671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
22672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
22673 if (SWIG_arg_fail(1)) SWIG_fail;
22674 {
22675 PyThreadState* __tstate = wxPyBeginAllowThreads();
22676 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
22677
22678 wxPyEndAllowThreads(__tstate);
22679 if (PyErr_Occurred()) SWIG_fail;
22680 }
22681 {
22682 resultobj = wxPyMake_wxObject(result, (bool)0);
22683 }
22684 return resultobj;
22685 fail:
22686 return NULL;
22687 }
22688
22689
22690 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
22691 PyObject *obj;
22692 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22693 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
22694 Py_INCREF(obj);
22695 return Py_BuildValue((char *)"");
22696 }
22697 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22698 PyObject *resultobj = NULL;
22699 wxWindow *arg1 = (wxWindow *) NULL ;
22700 wxWindowDestroyEvent *result;
22701 PyObject * obj0 = 0 ;
22702 char *kwnames[] = {
22703 (char *) "win", NULL
22704 };
22705
22706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
22707 if (obj0) {
22708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22709 if (SWIG_arg_fail(1)) SWIG_fail;
22710 }
22711 {
22712 PyThreadState* __tstate = wxPyBeginAllowThreads();
22713 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
22714
22715 wxPyEndAllowThreads(__tstate);
22716 if (PyErr_Occurred()) SWIG_fail;
22717 }
22718 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
22719 return resultobj;
22720 fail:
22721 return NULL;
22722 }
22723
22724
22725 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22726 PyObject *resultobj = NULL;
22727 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
22728 wxWindow *result;
22729 PyObject * obj0 = 0 ;
22730 char *kwnames[] = {
22731 (char *) "self", NULL
22732 };
22733
22734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
22735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
22736 if (SWIG_arg_fail(1)) SWIG_fail;
22737 {
22738 PyThreadState* __tstate = wxPyBeginAllowThreads();
22739 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
22740
22741 wxPyEndAllowThreads(__tstate);
22742 if (PyErr_Occurred()) SWIG_fail;
22743 }
22744 {
22745 resultobj = wxPyMake_wxObject(result, (bool)0);
22746 }
22747 return resultobj;
22748 fail:
22749 return NULL;
22750 }
22751
22752
22753 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
22754 PyObject *obj;
22755 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22756 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
22757 Py_INCREF(obj);
22758 return Py_BuildValue((char *)"");
22759 }
22760 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22761 PyObject *resultobj = NULL;
22762 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22763 int arg2 = (int) 0 ;
22764 wxPoint const &arg3_defvalue = wxDefaultPosition ;
22765 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
22766 wxContextMenuEvent *result;
22767 wxPoint temp3 ;
22768 PyObject * obj0 = 0 ;
22769 PyObject * obj1 = 0 ;
22770 PyObject * obj2 = 0 ;
22771 char *kwnames[] = {
22772 (char *) "type",(char *) "winid",(char *) "pt", NULL
22773 };
22774
22775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22776 if (obj0) {
22777 {
22778 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
22779 if (SWIG_arg_fail(1)) SWIG_fail;
22780 }
22781 }
22782 if (obj1) {
22783 {
22784 arg2 = static_cast<int >(SWIG_As_int(obj1));
22785 if (SWIG_arg_fail(2)) SWIG_fail;
22786 }
22787 }
22788 if (obj2) {
22789 {
22790 arg3 = &temp3;
22791 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22792 }
22793 }
22794 {
22795 PyThreadState* __tstate = wxPyBeginAllowThreads();
22796 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22797
22798 wxPyEndAllowThreads(__tstate);
22799 if (PyErr_Occurred()) SWIG_fail;
22800 }
22801 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22802 return resultobj;
22803 fail:
22804 return NULL;
22805 }
22806
22807
22808 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22809 PyObject *resultobj = NULL;
22810 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22811 wxPoint *result;
22812 PyObject * obj0 = 0 ;
22813 char *kwnames[] = {
22814 (char *) "self", NULL
22815 };
22816
22817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22819 if (SWIG_arg_fail(1)) SWIG_fail;
22820 {
22821 PyThreadState* __tstate = wxPyBeginAllowThreads();
22822 {
22823 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22824 result = (wxPoint *) &_result_ref;
22825 }
22826
22827 wxPyEndAllowThreads(__tstate);
22828 if (PyErr_Occurred()) SWIG_fail;
22829 }
22830 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22831 return resultobj;
22832 fail:
22833 return NULL;
22834 }
22835
22836
22837 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22838 PyObject *resultobj = NULL;
22839 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22840 wxPoint *arg2 = 0 ;
22841 wxPoint temp2 ;
22842 PyObject * obj0 = 0 ;
22843 PyObject * obj1 = 0 ;
22844 char *kwnames[] = {
22845 (char *) "self",(char *) "pos", NULL
22846 };
22847
22848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22850 if (SWIG_arg_fail(1)) SWIG_fail;
22851 {
22852 arg2 = &temp2;
22853 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22854 }
22855 {
22856 PyThreadState* __tstate = wxPyBeginAllowThreads();
22857 (arg1)->SetPosition((wxPoint const &)*arg2);
22858
22859 wxPyEndAllowThreads(__tstate);
22860 if (PyErr_Occurred()) SWIG_fail;
22861 }
22862 Py_INCREF(Py_None); resultobj = Py_None;
22863 return resultobj;
22864 fail:
22865 return NULL;
22866 }
22867
22868
22869 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22870 PyObject *obj;
22871 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22872 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22873 Py_INCREF(obj);
22874 return Py_BuildValue((char *)"");
22875 }
22876 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22877 PyObject *resultobj = NULL;
22878 wxIdleEvent *result;
22879 char *kwnames[] = {
22880 NULL
22881 };
22882
22883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22884 {
22885 PyThreadState* __tstate = wxPyBeginAllowThreads();
22886 result = (wxIdleEvent *)new wxIdleEvent();
22887
22888 wxPyEndAllowThreads(__tstate);
22889 if (PyErr_Occurred()) SWIG_fail;
22890 }
22891 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22892 return resultobj;
22893 fail:
22894 return NULL;
22895 }
22896
22897
22898 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22899 PyObject *resultobj = NULL;
22900 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22901 bool arg2 = (bool) true ;
22902 PyObject * obj0 = 0 ;
22903 PyObject * obj1 = 0 ;
22904 char *kwnames[] = {
22905 (char *) "self",(char *) "needMore", NULL
22906 };
22907
22908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22910 if (SWIG_arg_fail(1)) SWIG_fail;
22911 if (obj1) {
22912 {
22913 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22914 if (SWIG_arg_fail(2)) SWIG_fail;
22915 }
22916 }
22917 {
22918 PyThreadState* __tstate = wxPyBeginAllowThreads();
22919 (arg1)->RequestMore(arg2);
22920
22921 wxPyEndAllowThreads(__tstate);
22922 if (PyErr_Occurred()) SWIG_fail;
22923 }
22924 Py_INCREF(Py_None); resultobj = Py_None;
22925 return resultobj;
22926 fail:
22927 return NULL;
22928 }
22929
22930
22931 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22932 PyObject *resultobj = NULL;
22933 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22934 bool result;
22935 PyObject * obj0 = 0 ;
22936 char *kwnames[] = {
22937 (char *) "self", NULL
22938 };
22939
22940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22942 if (SWIG_arg_fail(1)) SWIG_fail;
22943 {
22944 PyThreadState* __tstate = wxPyBeginAllowThreads();
22945 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22946
22947 wxPyEndAllowThreads(__tstate);
22948 if (PyErr_Occurred()) SWIG_fail;
22949 }
22950 {
22951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22952 }
22953 return resultobj;
22954 fail:
22955 return NULL;
22956 }
22957
22958
22959 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22960 PyObject *resultobj = NULL;
22961 wxIdleMode arg1 ;
22962 PyObject * obj0 = 0 ;
22963 char *kwnames[] = {
22964 (char *) "mode", NULL
22965 };
22966
22967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22968 {
22969 arg1 = static_cast<wxIdleMode >(SWIG_As_int(obj0));
22970 if (SWIG_arg_fail(1)) SWIG_fail;
22971 }
22972 {
22973 PyThreadState* __tstate = wxPyBeginAllowThreads();
22974 wxIdleEvent::SetMode(arg1);
22975
22976 wxPyEndAllowThreads(__tstate);
22977 if (PyErr_Occurred()) SWIG_fail;
22978 }
22979 Py_INCREF(Py_None); resultobj = Py_None;
22980 return resultobj;
22981 fail:
22982 return NULL;
22983 }
22984
22985
22986 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22987 PyObject *resultobj = NULL;
22988 wxIdleMode result;
22989 char *kwnames[] = {
22990 NULL
22991 };
22992
22993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22994 {
22995 PyThreadState* __tstate = wxPyBeginAllowThreads();
22996 result = (wxIdleMode)wxIdleEvent::GetMode();
22997
22998 wxPyEndAllowThreads(__tstate);
22999 if (PyErr_Occurred()) SWIG_fail;
23000 }
23001 resultobj = SWIG_From_int((result));
23002 return resultobj;
23003 fail:
23004 return NULL;
23005 }
23006
23007
23008 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
23009 PyObject *resultobj = NULL;
23010 wxWindow *arg1 = (wxWindow *) 0 ;
23011 bool result;
23012 PyObject * obj0 = 0 ;
23013 char *kwnames[] = {
23014 (char *) "win", NULL
23015 };
23016
23017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
23018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23019 if (SWIG_arg_fail(1)) SWIG_fail;
23020 {
23021 PyThreadState* __tstate = wxPyBeginAllowThreads();
23022 result = (bool)wxIdleEvent::CanSend(arg1);
23023
23024 wxPyEndAllowThreads(__tstate);
23025 if (PyErr_Occurred()) SWIG_fail;
23026 }
23027 {
23028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23029 }
23030 return resultobj;
23031 fail:
23032 return NULL;
23033 }
23034
23035
23036 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
23037 PyObject *obj;
23038 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23039 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
23040 Py_INCREF(obj);
23041 return Py_BuildValue((char *)"");
23042 }
23043 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23044 PyObject *resultobj = NULL;
23045 int arg1 = (int) 0 ;
23046 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
23047 wxPyEvent *result;
23048 PyObject * obj0 = 0 ;
23049 PyObject * obj1 = 0 ;
23050 char *kwnames[] = {
23051 (char *) "winid",(char *) "eventType", NULL
23052 };
23053
23054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
23055 if (obj0) {
23056 {
23057 arg1 = static_cast<int >(SWIG_As_int(obj0));
23058 if (SWIG_arg_fail(1)) SWIG_fail;
23059 }
23060 }
23061 if (obj1) {
23062 {
23063 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
23064 if (SWIG_arg_fail(2)) SWIG_fail;
23065 }
23066 }
23067 {
23068 PyThreadState* __tstate = wxPyBeginAllowThreads();
23069 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
23070
23071 wxPyEndAllowThreads(__tstate);
23072 if (PyErr_Occurred()) SWIG_fail;
23073 }
23074 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
23075 return resultobj;
23076 fail:
23077 return NULL;
23078 }
23079
23080
23081 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23082 PyObject *resultobj = NULL;
23083 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23084 PyObject * obj0 = 0 ;
23085 char *kwnames[] = {
23086 (char *) "self", NULL
23087 };
23088
23089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
23090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23091 if (SWIG_arg_fail(1)) SWIG_fail;
23092 {
23093 PyThreadState* __tstate = wxPyBeginAllowThreads();
23094 delete arg1;
23095
23096 wxPyEndAllowThreads(__tstate);
23097 if (PyErr_Occurred()) SWIG_fail;
23098 }
23099 Py_INCREF(Py_None); resultobj = Py_None;
23100 return resultobj;
23101 fail:
23102 return NULL;
23103 }
23104
23105
23106 static PyObject *_wrap_PyEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23107 PyObject *resultobj = NULL;
23108 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23109 PyObject *arg2 = (PyObject *) 0 ;
23110 PyObject * obj0 = 0 ;
23111 PyObject * obj1 = 0 ;
23112 char *kwnames[] = {
23113 (char *) "self",(char *) "self", NULL
23114 };
23115
23116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23118 if (SWIG_arg_fail(1)) SWIG_fail;
23119 arg2 = obj1;
23120 {
23121 PyThreadState* __tstate = wxPyBeginAllowThreads();
23122 (arg1)->SetSelf(arg2);
23123
23124 wxPyEndAllowThreads(__tstate);
23125 if (PyErr_Occurred()) SWIG_fail;
23126 }
23127 Py_INCREF(Py_None); resultobj = Py_None;
23128 return resultobj;
23129 fail:
23130 return NULL;
23131 }
23132
23133
23134 static PyObject *_wrap_PyEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23135 PyObject *resultobj = NULL;
23136 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23137 PyObject *result;
23138 PyObject * obj0 = 0 ;
23139 char *kwnames[] = {
23140 (char *) "self", NULL
23141 };
23142
23143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent__GetSelf",kwnames,&obj0)) goto fail;
23144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23145 if (SWIG_arg_fail(1)) SWIG_fail;
23146 {
23147 PyThreadState* __tstate = wxPyBeginAllowThreads();
23148 result = (PyObject *)(arg1)->GetSelf();
23149
23150 wxPyEndAllowThreads(__tstate);
23151 if (PyErr_Occurred()) SWIG_fail;
23152 }
23153 resultobj = result;
23154 return resultobj;
23155 fail:
23156 return NULL;
23157 }
23158
23159
23160 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
23161 PyObject *obj;
23162 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23163 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
23164 Py_INCREF(obj);
23165 return Py_BuildValue((char *)"");
23166 }
23167 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23168 PyObject *resultobj = NULL;
23169 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23170 int arg2 = (int) 0 ;
23171 wxPyCommandEvent *result;
23172 PyObject * obj0 = 0 ;
23173 PyObject * obj1 = 0 ;
23174 char *kwnames[] = {
23175 (char *) "eventType",(char *) "id", NULL
23176 };
23177
23178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
23179 if (obj0) {
23180 {
23181 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
23182 if (SWIG_arg_fail(1)) SWIG_fail;
23183 }
23184 }
23185 if (obj1) {
23186 {
23187 arg2 = static_cast<int >(SWIG_As_int(obj1));
23188 if (SWIG_arg_fail(2)) SWIG_fail;
23189 }
23190 }
23191 {
23192 PyThreadState* __tstate = wxPyBeginAllowThreads();
23193 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
23194
23195 wxPyEndAllowThreads(__tstate);
23196 if (PyErr_Occurred()) SWIG_fail;
23197 }
23198 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
23199 return resultobj;
23200 fail:
23201 return NULL;
23202 }
23203
23204
23205 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23206 PyObject *resultobj = NULL;
23207 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23208 PyObject * obj0 = 0 ;
23209 char *kwnames[] = {
23210 (char *) "self", NULL
23211 };
23212
23213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
23214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23215 if (SWIG_arg_fail(1)) SWIG_fail;
23216 {
23217 PyThreadState* __tstate = wxPyBeginAllowThreads();
23218 delete arg1;
23219
23220 wxPyEndAllowThreads(__tstate);
23221 if (PyErr_Occurred()) SWIG_fail;
23222 }
23223 Py_INCREF(Py_None); resultobj = Py_None;
23224 return resultobj;
23225 fail:
23226 return NULL;
23227 }
23228
23229
23230 static PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23231 PyObject *resultobj = NULL;
23232 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23233 PyObject *arg2 = (PyObject *) 0 ;
23234 PyObject * obj0 = 0 ;
23235 PyObject * obj1 = 0 ;
23236 char *kwnames[] = {
23237 (char *) "self",(char *) "self", NULL
23238 };
23239
23240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23242 if (SWIG_arg_fail(1)) SWIG_fail;
23243 arg2 = obj1;
23244 {
23245 PyThreadState* __tstate = wxPyBeginAllowThreads();
23246 (arg1)->SetSelf(arg2);
23247
23248 wxPyEndAllowThreads(__tstate);
23249 if (PyErr_Occurred()) SWIG_fail;
23250 }
23251 Py_INCREF(Py_None); resultobj = Py_None;
23252 return resultobj;
23253 fail:
23254 return NULL;
23255 }
23256
23257
23258 static PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23259 PyObject *resultobj = NULL;
23260 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23261 PyObject *result;
23262 PyObject * obj0 = 0 ;
23263 char *kwnames[] = {
23264 (char *) "self", NULL
23265 };
23266
23267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent__GetSelf",kwnames,&obj0)) goto fail;
23268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23269 if (SWIG_arg_fail(1)) SWIG_fail;
23270 {
23271 PyThreadState* __tstate = wxPyBeginAllowThreads();
23272 result = (PyObject *)(arg1)->GetSelf();
23273
23274 wxPyEndAllowThreads(__tstate);
23275 if (PyErr_Occurred()) SWIG_fail;
23276 }
23277 resultobj = result;
23278 return resultobj;
23279 fail:
23280 return NULL;
23281 }
23282
23283
23284 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
23285 PyObject *obj;
23286 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23287 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
23288 Py_INCREF(obj);
23289 return Py_BuildValue((char *)"");
23290 }
23291 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23292 PyObject *resultobj = NULL;
23293 wxWindow *arg1 = (wxWindow *) 0 ;
23294 wxDateTime *arg2 = 0 ;
23295 wxEventType arg3 ;
23296 wxDateEvent *result;
23297 PyObject * obj0 = 0 ;
23298 PyObject * obj1 = 0 ;
23299 PyObject * obj2 = 0 ;
23300 char *kwnames[] = {
23301 (char *) "win",(char *) "dt",(char *) "type", NULL
23302 };
23303
23304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
23305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23306 if (SWIG_arg_fail(1)) SWIG_fail;
23307 {
23308 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23309 if (SWIG_arg_fail(2)) SWIG_fail;
23310 if (arg2 == NULL) {
23311 SWIG_null_ref("wxDateTime");
23312 }
23313 if (SWIG_arg_fail(2)) SWIG_fail;
23314 }
23315 {
23316 arg3 = static_cast<wxEventType >(SWIG_As_int(obj2));
23317 if (SWIG_arg_fail(3)) SWIG_fail;
23318 }
23319 {
23320 PyThreadState* __tstate = wxPyBeginAllowThreads();
23321 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
23322
23323 wxPyEndAllowThreads(__tstate);
23324 if (PyErr_Occurred()) SWIG_fail;
23325 }
23326 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
23327 return resultobj;
23328 fail:
23329 return NULL;
23330 }
23331
23332
23333 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23334 PyObject *resultobj = NULL;
23335 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23336 wxDateTime *result;
23337 PyObject * obj0 = 0 ;
23338 char *kwnames[] = {
23339 (char *) "self", NULL
23340 };
23341
23342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
23343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23344 if (SWIG_arg_fail(1)) SWIG_fail;
23345 {
23346 PyThreadState* __tstate = wxPyBeginAllowThreads();
23347 {
23348 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
23349 result = (wxDateTime *) &_result_ref;
23350 }
23351
23352 wxPyEndAllowThreads(__tstate);
23353 if (PyErr_Occurred()) SWIG_fail;
23354 }
23355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23356 return resultobj;
23357 fail:
23358 return NULL;
23359 }
23360
23361
23362 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23363 PyObject *resultobj = NULL;
23364 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23365 wxDateTime *arg2 = 0 ;
23366 PyObject * obj0 = 0 ;
23367 PyObject * obj1 = 0 ;
23368 char *kwnames[] = {
23369 (char *) "self",(char *) "date", NULL
23370 };
23371
23372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
23373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23374 if (SWIG_arg_fail(1)) SWIG_fail;
23375 {
23376 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23377 if (SWIG_arg_fail(2)) SWIG_fail;
23378 if (arg2 == NULL) {
23379 SWIG_null_ref("wxDateTime");
23380 }
23381 if (SWIG_arg_fail(2)) SWIG_fail;
23382 }
23383 {
23384 PyThreadState* __tstate = wxPyBeginAllowThreads();
23385 (arg1)->SetDate((wxDateTime const &)*arg2);
23386
23387 wxPyEndAllowThreads(__tstate);
23388 if (PyErr_Occurred()) SWIG_fail;
23389 }
23390 Py_INCREF(Py_None); resultobj = Py_None;
23391 return resultobj;
23392 fail:
23393 return NULL;
23394 }
23395
23396
23397 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
23398 PyObject *obj;
23399 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23400 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
23401 Py_INCREF(obj);
23402 return Py_BuildValue((char *)"");
23403 }
23404 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23405 PyObject *resultobj = NULL;
23406 wxPyApp *result;
23407 char *kwnames[] = {
23408 NULL
23409 };
23410
23411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
23412 {
23413 PyThreadState* __tstate = wxPyBeginAllowThreads();
23414 result = (wxPyApp *)new_wxPyApp();
23415
23416 wxPyEndAllowThreads(__tstate);
23417 if (PyErr_Occurred()) SWIG_fail;
23418 }
23419 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
23420 return resultobj;
23421 fail:
23422 return NULL;
23423 }
23424
23425
23426 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23427 PyObject *resultobj = NULL;
23428 wxPyApp *arg1 = (wxPyApp *) 0 ;
23429 PyObject * obj0 = 0 ;
23430 char *kwnames[] = {
23431 (char *) "self", NULL
23432 };
23433
23434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
23435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23436 if (SWIG_arg_fail(1)) SWIG_fail;
23437 {
23438 PyThreadState* __tstate = wxPyBeginAllowThreads();
23439 delete arg1;
23440
23441 wxPyEndAllowThreads(__tstate);
23442 if (PyErr_Occurred()) SWIG_fail;
23443 }
23444 Py_INCREF(Py_None); resultobj = Py_None;
23445 return resultobj;
23446 fail:
23447 return NULL;
23448 }
23449
23450
23451 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
23452 PyObject *resultobj = NULL;
23453 wxPyApp *arg1 = (wxPyApp *) 0 ;
23454 PyObject *arg2 = (PyObject *) 0 ;
23455 PyObject *arg3 = (PyObject *) 0 ;
23456 bool arg4 ;
23457 PyObject * obj0 = 0 ;
23458 PyObject * obj1 = 0 ;
23459 PyObject * obj2 = 0 ;
23460 PyObject * obj3 = 0 ;
23461 char *kwnames[] = {
23462 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
23463 };
23464
23465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23467 if (SWIG_arg_fail(1)) SWIG_fail;
23468 arg2 = obj1;
23469 arg3 = obj2;
23470 {
23471 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
23472 if (SWIG_arg_fail(4)) SWIG_fail;
23473 }
23474 {
23475 PyThreadState* __tstate = wxPyBeginAllowThreads();
23476 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
23477
23478 wxPyEndAllowThreads(__tstate);
23479 if (PyErr_Occurred()) SWIG_fail;
23480 }
23481 Py_INCREF(Py_None); resultobj = Py_None;
23482 return resultobj;
23483 fail:
23484 return NULL;
23485 }
23486
23487
23488 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23489 PyObject *resultobj = NULL;
23490 wxPyApp *arg1 = (wxPyApp *) 0 ;
23491 wxString result;
23492 PyObject * obj0 = 0 ;
23493 char *kwnames[] = {
23494 (char *) "self", NULL
23495 };
23496
23497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
23498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23499 if (SWIG_arg_fail(1)) SWIG_fail;
23500 {
23501 PyThreadState* __tstate = wxPyBeginAllowThreads();
23502 result = ((wxPyApp const *)arg1)->GetAppName();
23503
23504 wxPyEndAllowThreads(__tstate);
23505 if (PyErr_Occurred()) SWIG_fail;
23506 }
23507 {
23508 #if wxUSE_UNICODE
23509 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23510 #else
23511 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23512 #endif
23513 }
23514 return resultobj;
23515 fail:
23516 return NULL;
23517 }
23518
23519
23520 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23521 PyObject *resultobj = NULL;
23522 wxPyApp *arg1 = (wxPyApp *) 0 ;
23523 wxString *arg2 = 0 ;
23524 bool temp2 = false ;
23525 PyObject * obj0 = 0 ;
23526 PyObject * obj1 = 0 ;
23527 char *kwnames[] = {
23528 (char *) "self",(char *) "name", NULL
23529 };
23530
23531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
23532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23533 if (SWIG_arg_fail(1)) SWIG_fail;
23534 {
23535 arg2 = wxString_in_helper(obj1);
23536 if (arg2 == NULL) SWIG_fail;
23537 temp2 = true;
23538 }
23539 {
23540 PyThreadState* __tstate = wxPyBeginAllowThreads();
23541 (arg1)->SetAppName((wxString const &)*arg2);
23542
23543 wxPyEndAllowThreads(__tstate);
23544 if (PyErr_Occurred()) SWIG_fail;
23545 }
23546 Py_INCREF(Py_None); resultobj = Py_None;
23547 {
23548 if (temp2)
23549 delete arg2;
23550 }
23551 return resultobj;
23552 fail:
23553 {
23554 if (temp2)
23555 delete arg2;
23556 }
23557 return NULL;
23558 }
23559
23560
23561 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23562 PyObject *resultobj = NULL;
23563 wxPyApp *arg1 = (wxPyApp *) 0 ;
23564 wxString result;
23565 PyObject * obj0 = 0 ;
23566 char *kwnames[] = {
23567 (char *) "self", NULL
23568 };
23569
23570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
23571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23572 if (SWIG_arg_fail(1)) SWIG_fail;
23573 {
23574 PyThreadState* __tstate = wxPyBeginAllowThreads();
23575 result = ((wxPyApp const *)arg1)->GetClassName();
23576
23577 wxPyEndAllowThreads(__tstate);
23578 if (PyErr_Occurred()) SWIG_fail;
23579 }
23580 {
23581 #if wxUSE_UNICODE
23582 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23583 #else
23584 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23585 #endif
23586 }
23587 return resultobj;
23588 fail:
23589 return NULL;
23590 }
23591
23592
23593 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23594 PyObject *resultobj = NULL;
23595 wxPyApp *arg1 = (wxPyApp *) 0 ;
23596 wxString *arg2 = 0 ;
23597 bool temp2 = false ;
23598 PyObject * obj0 = 0 ;
23599 PyObject * obj1 = 0 ;
23600 char *kwnames[] = {
23601 (char *) "self",(char *) "name", NULL
23602 };
23603
23604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
23605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23606 if (SWIG_arg_fail(1)) SWIG_fail;
23607 {
23608 arg2 = wxString_in_helper(obj1);
23609 if (arg2 == NULL) SWIG_fail;
23610 temp2 = true;
23611 }
23612 {
23613 PyThreadState* __tstate = wxPyBeginAllowThreads();
23614 (arg1)->SetClassName((wxString const &)*arg2);
23615
23616 wxPyEndAllowThreads(__tstate);
23617 if (PyErr_Occurred()) SWIG_fail;
23618 }
23619 Py_INCREF(Py_None); resultobj = Py_None;
23620 {
23621 if (temp2)
23622 delete arg2;
23623 }
23624 return resultobj;
23625 fail:
23626 {
23627 if (temp2)
23628 delete arg2;
23629 }
23630 return NULL;
23631 }
23632
23633
23634 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23635 PyObject *resultobj = NULL;
23636 wxPyApp *arg1 = (wxPyApp *) 0 ;
23637 wxString *result;
23638 PyObject * obj0 = 0 ;
23639 char *kwnames[] = {
23640 (char *) "self", NULL
23641 };
23642
23643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
23644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23645 if (SWIG_arg_fail(1)) SWIG_fail;
23646 {
23647 PyThreadState* __tstate = wxPyBeginAllowThreads();
23648 {
23649 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
23650 result = (wxString *) &_result_ref;
23651 }
23652
23653 wxPyEndAllowThreads(__tstate);
23654 if (PyErr_Occurred()) SWIG_fail;
23655 }
23656 {
23657 #if wxUSE_UNICODE
23658 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23659 #else
23660 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23661 #endif
23662 }
23663 return resultobj;
23664 fail:
23665 return NULL;
23666 }
23667
23668
23669 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23670 PyObject *resultobj = NULL;
23671 wxPyApp *arg1 = (wxPyApp *) 0 ;
23672 wxString *arg2 = 0 ;
23673 bool temp2 = false ;
23674 PyObject * obj0 = 0 ;
23675 PyObject * obj1 = 0 ;
23676 char *kwnames[] = {
23677 (char *) "self",(char *) "name", NULL
23678 };
23679
23680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
23681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23682 if (SWIG_arg_fail(1)) SWIG_fail;
23683 {
23684 arg2 = wxString_in_helper(obj1);
23685 if (arg2 == NULL) SWIG_fail;
23686 temp2 = true;
23687 }
23688 {
23689 PyThreadState* __tstate = wxPyBeginAllowThreads();
23690 (arg1)->SetVendorName((wxString const &)*arg2);
23691
23692 wxPyEndAllowThreads(__tstate);
23693 if (PyErr_Occurred()) SWIG_fail;
23694 }
23695 Py_INCREF(Py_None); resultobj = Py_None;
23696 {
23697 if (temp2)
23698 delete arg2;
23699 }
23700 return resultobj;
23701 fail:
23702 {
23703 if (temp2)
23704 delete arg2;
23705 }
23706 return NULL;
23707 }
23708
23709
23710 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
23711 PyObject *resultobj = NULL;
23712 wxPyApp *arg1 = (wxPyApp *) 0 ;
23713 wxAppTraits *result;
23714 PyObject * obj0 = 0 ;
23715 char *kwnames[] = {
23716 (char *) "self", NULL
23717 };
23718
23719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
23720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23721 if (SWIG_arg_fail(1)) SWIG_fail;
23722 {
23723 PyThreadState* __tstate = wxPyBeginAllowThreads();
23724 result = (wxAppTraits *)(arg1)->GetTraits();
23725
23726 wxPyEndAllowThreads(__tstate);
23727 if (PyErr_Occurred()) SWIG_fail;
23728 }
23729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
23730 return resultobj;
23731 fail:
23732 return NULL;
23733 }
23734
23735
23736 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23737 PyObject *resultobj = NULL;
23738 wxPyApp *arg1 = (wxPyApp *) 0 ;
23739 PyObject * obj0 = 0 ;
23740 char *kwnames[] = {
23741 (char *) "self", NULL
23742 };
23743
23744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
23745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23746 if (SWIG_arg_fail(1)) SWIG_fail;
23747 {
23748 PyThreadState* __tstate = wxPyBeginAllowThreads();
23749 (arg1)->ProcessPendingEvents();
23750
23751 wxPyEndAllowThreads(__tstate);
23752 if (PyErr_Occurred()) SWIG_fail;
23753 }
23754 Py_INCREF(Py_None); resultobj = Py_None;
23755 return resultobj;
23756 fail:
23757 return NULL;
23758 }
23759
23760
23761 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23762 PyObject *resultobj = NULL;
23763 wxPyApp *arg1 = (wxPyApp *) 0 ;
23764 bool arg2 = (bool) false ;
23765 bool result;
23766 PyObject * obj0 = 0 ;
23767 PyObject * obj1 = 0 ;
23768 char *kwnames[] = {
23769 (char *) "self",(char *) "onlyIfNeeded", NULL
23770 };
23771
23772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
23773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23774 if (SWIG_arg_fail(1)) SWIG_fail;
23775 if (obj1) {
23776 {
23777 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
23778 if (SWIG_arg_fail(2)) SWIG_fail;
23779 }
23780 }
23781 {
23782 PyThreadState* __tstate = wxPyBeginAllowThreads();
23783 result = (bool)(arg1)->Yield(arg2);
23784
23785 wxPyEndAllowThreads(__tstate);
23786 if (PyErr_Occurred()) SWIG_fail;
23787 }
23788 {
23789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23790 }
23791 return resultobj;
23792 fail:
23793 return NULL;
23794 }
23795
23796
23797 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23798 PyObject *resultobj = NULL;
23799 wxPyApp *arg1 = (wxPyApp *) 0 ;
23800 PyObject * obj0 = 0 ;
23801 char *kwnames[] = {
23802 (char *) "self", NULL
23803 };
23804
23805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23807 if (SWIG_arg_fail(1)) SWIG_fail;
23808 {
23809 PyThreadState* __tstate = wxPyBeginAllowThreads();
23810 (arg1)->WakeUpIdle();
23811
23812 wxPyEndAllowThreads(__tstate);
23813 if (PyErr_Occurred()) SWIG_fail;
23814 }
23815 Py_INCREF(Py_None); resultobj = Py_None;
23816 return resultobj;
23817 fail:
23818 return NULL;
23819 }
23820
23821
23822 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23823 PyObject *resultobj = NULL;
23824 bool result;
23825 char *kwnames[] = {
23826 NULL
23827 };
23828
23829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23830 {
23831 PyThreadState* __tstate = wxPyBeginAllowThreads();
23832 result = (bool)wxPyApp::IsMainLoopRunning();
23833
23834 wxPyEndAllowThreads(__tstate);
23835 if (PyErr_Occurred()) SWIG_fail;
23836 }
23837 {
23838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23839 }
23840 return resultobj;
23841 fail:
23842 return NULL;
23843 }
23844
23845
23846 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23847 PyObject *resultobj = NULL;
23848 wxPyApp *arg1 = (wxPyApp *) 0 ;
23849 int result;
23850 PyObject * obj0 = 0 ;
23851 char *kwnames[] = {
23852 (char *) "self", NULL
23853 };
23854
23855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23857 if (SWIG_arg_fail(1)) SWIG_fail;
23858 {
23859 PyThreadState* __tstate = wxPyBeginAllowThreads();
23860 result = (int)(arg1)->MainLoop();
23861
23862 wxPyEndAllowThreads(__tstate);
23863 if (PyErr_Occurred()) SWIG_fail;
23864 }
23865 {
23866 resultobj = SWIG_From_int(static_cast<int >(result));
23867 }
23868 return resultobj;
23869 fail:
23870 return NULL;
23871 }
23872
23873
23874 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23875 PyObject *resultobj = NULL;
23876 wxPyApp *arg1 = (wxPyApp *) 0 ;
23877 PyObject * obj0 = 0 ;
23878 char *kwnames[] = {
23879 (char *) "self", NULL
23880 };
23881
23882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23884 if (SWIG_arg_fail(1)) SWIG_fail;
23885 {
23886 PyThreadState* __tstate = wxPyBeginAllowThreads();
23887 (arg1)->Exit();
23888
23889 wxPyEndAllowThreads(__tstate);
23890 if (PyErr_Occurred()) SWIG_fail;
23891 }
23892 Py_INCREF(Py_None); resultobj = Py_None;
23893 return resultobj;
23894 fail:
23895 return NULL;
23896 }
23897
23898
23899 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23900 PyObject *resultobj = NULL;
23901 wxPyApp *arg1 = (wxPyApp *) 0 ;
23902 PyObject * obj0 = 0 ;
23903 char *kwnames[] = {
23904 (char *) "self", NULL
23905 };
23906
23907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23909 if (SWIG_arg_fail(1)) SWIG_fail;
23910 {
23911 PyThreadState* __tstate = wxPyBeginAllowThreads();
23912 (arg1)->ExitMainLoop();
23913
23914 wxPyEndAllowThreads(__tstate);
23915 if (PyErr_Occurred()) SWIG_fail;
23916 }
23917 Py_INCREF(Py_None); resultobj = Py_None;
23918 return resultobj;
23919 fail:
23920 return NULL;
23921 }
23922
23923
23924 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23925 PyObject *resultobj = NULL;
23926 wxPyApp *arg1 = (wxPyApp *) 0 ;
23927 bool result;
23928 PyObject * obj0 = 0 ;
23929 char *kwnames[] = {
23930 (char *) "self", NULL
23931 };
23932
23933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23935 if (SWIG_arg_fail(1)) SWIG_fail;
23936 {
23937 PyThreadState* __tstate = wxPyBeginAllowThreads();
23938 result = (bool)(arg1)->Pending();
23939
23940 wxPyEndAllowThreads(__tstate);
23941 if (PyErr_Occurred()) SWIG_fail;
23942 }
23943 {
23944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23945 }
23946 return resultobj;
23947 fail:
23948 return NULL;
23949 }
23950
23951
23952 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23953 PyObject *resultobj = NULL;
23954 wxPyApp *arg1 = (wxPyApp *) 0 ;
23955 bool result;
23956 PyObject * obj0 = 0 ;
23957 char *kwnames[] = {
23958 (char *) "self", NULL
23959 };
23960
23961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23963 if (SWIG_arg_fail(1)) SWIG_fail;
23964 {
23965 PyThreadState* __tstate = wxPyBeginAllowThreads();
23966 result = (bool)(arg1)->Dispatch();
23967
23968 wxPyEndAllowThreads(__tstate);
23969 if (PyErr_Occurred()) SWIG_fail;
23970 }
23971 {
23972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23973 }
23974 return resultobj;
23975 fail:
23976 return NULL;
23977 }
23978
23979
23980 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23981 PyObject *resultobj = NULL;
23982 wxPyApp *arg1 = (wxPyApp *) 0 ;
23983 bool result;
23984 PyObject * obj0 = 0 ;
23985 char *kwnames[] = {
23986 (char *) "self", NULL
23987 };
23988
23989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23991 if (SWIG_arg_fail(1)) SWIG_fail;
23992 {
23993 PyThreadState* __tstate = wxPyBeginAllowThreads();
23994 result = (bool)(arg1)->ProcessIdle();
23995
23996 wxPyEndAllowThreads(__tstate);
23997 if (PyErr_Occurred()) SWIG_fail;
23998 }
23999 {
24000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24001 }
24002 return resultobj;
24003 fail:
24004 return NULL;
24005 }
24006
24007
24008 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
24009 PyObject *resultobj = NULL;
24010 wxPyApp *arg1 = (wxPyApp *) 0 ;
24011 wxWindow *arg2 = (wxWindow *) 0 ;
24012 wxIdleEvent *arg3 = 0 ;
24013 bool result;
24014 PyObject * obj0 = 0 ;
24015 PyObject * obj1 = 0 ;
24016 PyObject * obj2 = 0 ;
24017 char *kwnames[] = {
24018 (char *) "self",(char *) "win",(char *) "event", NULL
24019 };
24020
24021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
24022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24023 if (SWIG_arg_fail(1)) SWIG_fail;
24024 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24025 if (SWIG_arg_fail(2)) SWIG_fail;
24026 {
24027 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
24028 if (SWIG_arg_fail(3)) SWIG_fail;
24029 if (arg3 == NULL) {
24030 SWIG_null_ref("wxIdleEvent");
24031 }
24032 if (SWIG_arg_fail(3)) SWIG_fail;
24033 }
24034 {
24035 PyThreadState* __tstate = wxPyBeginAllowThreads();
24036 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
24037
24038 wxPyEndAllowThreads(__tstate);
24039 if (PyErr_Occurred()) SWIG_fail;
24040 }
24041 {
24042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24043 }
24044 return resultobj;
24045 fail:
24046 return NULL;
24047 }
24048
24049
24050 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
24051 PyObject *resultobj = NULL;
24052 wxPyApp *arg1 = (wxPyApp *) 0 ;
24053 bool result;
24054 PyObject * obj0 = 0 ;
24055 char *kwnames[] = {
24056 (char *) "self", NULL
24057 };
24058
24059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
24060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24061 if (SWIG_arg_fail(1)) SWIG_fail;
24062 {
24063 PyThreadState* __tstate = wxPyBeginAllowThreads();
24064 result = (bool)((wxPyApp const *)arg1)->IsActive();
24065
24066 wxPyEndAllowThreads(__tstate);
24067 if (PyErr_Occurred()) SWIG_fail;
24068 }
24069 {
24070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24071 }
24072 return resultobj;
24073 fail:
24074 return NULL;
24075 }
24076
24077
24078 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24079 PyObject *resultobj = NULL;
24080 wxPyApp *arg1 = (wxPyApp *) 0 ;
24081 wxWindow *arg2 = (wxWindow *) 0 ;
24082 PyObject * obj0 = 0 ;
24083 PyObject * obj1 = 0 ;
24084 char *kwnames[] = {
24085 (char *) "self",(char *) "win", NULL
24086 };
24087
24088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
24089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24090 if (SWIG_arg_fail(1)) SWIG_fail;
24091 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24092 if (SWIG_arg_fail(2)) SWIG_fail;
24093 {
24094 PyThreadState* __tstate = wxPyBeginAllowThreads();
24095 (arg1)->SetTopWindow(arg2);
24096
24097 wxPyEndAllowThreads(__tstate);
24098 if (PyErr_Occurred()) SWIG_fail;
24099 }
24100 Py_INCREF(Py_None); resultobj = Py_None;
24101 return resultobj;
24102 fail:
24103 return NULL;
24104 }
24105
24106
24107 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24108 PyObject *resultobj = NULL;
24109 wxPyApp *arg1 = (wxPyApp *) 0 ;
24110 wxWindow *result;
24111 PyObject * obj0 = 0 ;
24112 char *kwnames[] = {
24113 (char *) "self", NULL
24114 };
24115
24116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
24117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24118 if (SWIG_arg_fail(1)) SWIG_fail;
24119 {
24120 PyThreadState* __tstate = wxPyBeginAllowThreads();
24121 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
24122
24123 wxPyEndAllowThreads(__tstate);
24124 if (PyErr_Occurred()) SWIG_fail;
24125 }
24126 {
24127 resultobj = wxPyMake_wxObject(result, (bool)0);
24128 }
24129 return resultobj;
24130 fail:
24131 return NULL;
24132 }
24133
24134
24135 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
24136 PyObject *resultobj = NULL;
24137 wxPyApp *arg1 = (wxPyApp *) 0 ;
24138 bool arg2 ;
24139 PyObject * obj0 = 0 ;
24140 PyObject * obj1 = 0 ;
24141 char *kwnames[] = {
24142 (char *) "self",(char *) "flag", NULL
24143 };
24144
24145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
24146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24147 if (SWIG_arg_fail(1)) SWIG_fail;
24148 {
24149 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24150 if (SWIG_arg_fail(2)) SWIG_fail;
24151 }
24152 {
24153 PyThreadState* __tstate = wxPyBeginAllowThreads();
24154 (arg1)->SetExitOnFrameDelete(arg2);
24155
24156 wxPyEndAllowThreads(__tstate);
24157 if (PyErr_Occurred()) SWIG_fail;
24158 }
24159 Py_INCREF(Py_None); resultobj = Py_None;
24160 return resultobj;
24161 fail:
24162 return NULL;
24163 }
24164
24165
24166 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
24167 PyObject *resultobj = NULL;
24168 wxPyApp *arg1 = (wxPyApp *) 0 ;
24169 bool result;
24170 PyObject * obj0 = 0 ;
24171 char *kwnames[] = {
24172 (char *) "self", NULL
24173 };
24174
24175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
24176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24177 if (SWIG_arg_fail(1)) SWIG_fail;
24178 {
24179 PyThreadState* __tstate = wxPyBeginAllowThreads();
24180 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
24181
24182 wxPyEndAllowThreads(__tstate);
24183 if (PyErr_Occurred()) SWIG_fail;
24184 }
24185 {
24186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24187 }
24188 return resultobj;
24189 fail:
24190 return NULL;
24191 }
24192
24193
24194 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24195 PyObject *resultobj = NULL;
24196 wxPyApp *arg1 = (wxPyApp *) 0 ;
24197 bool arg2 ;
24198 PyObject * obj0 = 0 ;
24199 PyObject * obj1 = 0 ;
24200 char *kwnames[] = {
24201 (char *) "self",(char *) "flag", NULL
24202 };
24203
24204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
24205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24206 if (SWIG_arg_fail(1)) SWIG_fail;
24207 {
24208 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24209 if (SWIG_arg_fail(2)) SWIG_fail;
24210 }
24211 {
24212 PyThreadState* __tstate = wxPyBeginAllowThreads();
24213 (arg1)->SetUseBestVisual(arg2);
24214
24215 wxPyEndAllowThreads(__tstate);
24216 if (PyErr_Occurred()) SWIG_fail;
24217 }
24218 Py_INCREF(Py_None); resultobj = Py_None;
24219 return resultobj;
24220 fail:
24221 return NULL;
24222 }
24223
24224
24225 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24226 PyObject *resultobj = NULL;
24227 wxPyApp *arg1 = (wxPyApp *) 0 ;
24228 bool result;
24229 PyObject * obj0 = 0 ;
24230 char *kwnames[] = {
24231 (char *) "self", NULL
24232 };
24233
24234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
24235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24236 if (SWIG_arg_fail(1)) SWIG_fail;
24237 {
24238 PyThreadState* __tstate = wxPyBeginAllowThreads();
24239 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
24240
24241 wxPyEndAllowThreads(__tstate);
24242 if (PyErr_Occurred()) SWIG_fail;
24243 }
24244 {
24245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24246 }
24247 return resultobj;
24248 fail:
24249 return NULL;
24250 }
24251
24252
24253 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24254 PyObject *resultobj = NULL;
24255 wxPyApp *arg1 = (wxPyApp *) 0 ;
24256 int arg2 ;
24257 PyObject * obj0 = 0 ;
24258 PyObject * obj1 = 0 ;
24259 char *kwnames[] = {
24260 (char *) "self",(char *) "mode", NULL
24261 };
24262
24263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
24264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24265 if (SWIG_arg_fail(1)) SWIG_fail;
24266 {
24267 arg2 = static_cast<int >(SWIG_As_int(obj1));
24268 if (SWIG_arg_fail(2)) SWIG_fail;
24269 }
24270 {
24271 PyThreadState* __tstate = wxPyBeginAllowThreads();
24272 (arg1)->SetPrintMode(arg2);
24273
24274 wxPyEndAllowThreads(__tstate);
24275 if (PyErr_Occurred()) SWIG_fail;
24276 }
24277 Py_INCREF(Py_None); resultobj = Py_None;
24278 return resultobj;
24279 fail:
24280 return NULL;
24281 }
24282
24283
24284 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24285 PyObject *resultobj = NULL;
24286 wxPyApp *arg1 = (wxPyApp *) 0 ;
24287 int result;
24288 PyObject * obj0 = 0 ;
24289 char *kwnames[] = {
24290 (char *) "self", NULL
24291 };
24292
24293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
24294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24295 if (SWIG_arg_fail(1)) SWIG_fail;
24296 {
24297 PyThreadState* __tstate = wxPyBeginAllowThreads();
24298 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
24299
24300 wxPyEndAllowThreads(__tstate);
24301 if (PyErr_Occurred()) SWIG_fail;
24302 }
24303 {
24304 resultobj = SWIG_From_int(static_cast<int >(result));
24305 }
24306 return resultobj;
24307 fail:
24308 return NULL;
24309 }
24310
24311
24312 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24313 PyObject *resultobj = NULL;
24314 wxPyApp *arg1 = (wxPyApp *) 0 ;
24315 int arg2 ;
24316 PyObject * obj0 = 0 ;
24317 PyObject * obj1 = 0 ;
24318 char *kwnames[] = {
24319 (char *) "self",(char *) "mode", NULL
24320 };
24321
24322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
24323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24324 if (SWIG_arg_fail(1)) SWIG_fail;
24325 {
24326 arg2 = static_cast<int >(SWIG_As_int(obj1));
24327 if (SWIG_arg_fail(2)) SWIG_fail;
24328 }
24329 {
24330 PyThreadState* __tstate = wxPyBeginAllowThreads();
24331 (arg1)->SetAssertMode(arg2);
24332
24333 wxPyEndAllowThreads(__tstate);
24334 if (PyErr_Occurred()) SWIG_fail;
24335 }
24336 Py_INCREF(Py_None); resultobj = Py_None;
24337 return resultobj;
24338 fail:
24339 return NULL;
24340 }
24341
24342
24343 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24344 PyObject *resultobj = NULL;
24345 wxPyApp *arg1 = (wxPyApp *) 0 ;
24346 int result;
24347 PyObject * obj0 = 0 ;
24348 char *kwnames[] = {
24349 (char *) "self", NULL
24350 };
24351
24352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
24353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24354 if (SWIG_arg_fail(1)) SWIG_fail;
24355 {
24356 PyThreadState* __tstate = wxPyBeginAllowThreads();
24357 result = (int)(arg1)->GetAssertMode();
24358
24359 wxPyEndAllowThreads(__tstate);
24360 if (PyErr_Occurred()) SWIG_fail;
24361 }
24362 {
24363 resultobj = SWIG_From_int(static_cast<int >(result));
24364 }
24365 return resultobj;
24366 fail:
24367 return NULL;
24368 }
24369
24370
24371 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24372 PyObject *resultobj = NULL;
24373 bool result;
24374 char *kwnames[] = {
24375 NULL
24376 };
24377
24378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
24379 {
24380 PyThreadState* __tstate = wxPyBeginAllowThreads();
24381 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
24382
24383 wxPyEndAllowThreads(__tstate);
24384 if (PyErr_Occurred()) SWIG_fail;
24385 }
24386 {
24387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24388 }
24389 return resultobj;
24390 fail:
24391 return NULL;
24392 }
24393
24394
24395 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24396 PyObject *resultobj = NULL;
24397 long result;
24398 char *kwnames[] = {
24399 NULL
24400 };
24401
24402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
24403 {
24404 PyThreadState* __tstate = wxPyBeginAllowThreads();
24405 result = (long)wxPyApp::GetMacAboutMenuItemId();
24406
24407 wxPyEndAllowThreads(__tstate);
24408 if (PyErr_Occurred()) SWIG_fail;
24409 }
24410 {
24411 resultobj = SWIG_From_long(static_cast<long >(result));
24412 }
24413 return resultobj;
24414 fail:
24415 return NULL;
24416 }
24417
24418
24419 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24420 PyObject *resultobj = NULL;
24421 long result;
24422 char *kwnames[] = {
24423 NULL
24424 };
24425
24426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
24427 {
24428 PyThreadState* __tstate = wxPyBeginAllowThreads();
24429 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
24430
24431 wxPyEndAllowThreads(__tstate);
24432 if (PyErr_Occurred()) SWIG_fail;
24433 }
24434 {
24435 resultobj = SWIG_From_long(static_cast<long >(result));
24436 }
24437 return resultobj;
24438 fail:
24439 return NULL;
24440 }
24441
24442
24443 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24444 PyObject *resultobj = NULL;
24445 long result;
24446 char *kwnames[] = {
24447 NULL
24448 };
24449
24450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
24451 {
24452 PyThreadState* __tstate = wxPyBeginAllowThreads();
24453 result = (long)wxPyApp::GetMacExitMenuItemId();
24454
24455 wxPyEndAllowThreads(__tstate);
24456 if (PyErr_Occurred()) SWIG_fail;
24457 }
24458 {
24459 resultobj = SWIG_From_long(static_cast<long >(result));
24460 }
24461 return resultobj;
24462 fail:
24463 return NULL;
24464 }
24465
24466
24467 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24468 PyObject *resultobj = NULL;
24469 wxString result;
24470 char *kwnames[] = {
24471 NULL
24472 };
24473
24474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
24475 {
24476 PyThreadState* __tstate = wxPyBeginAllowThreads();
24477 result = wxPyApp::GetMacHelpMenuTitleName();
24478
24479 wxPyEndAllowThreads(__tstate);
24480 if (PyErr_Occurred()) SWIG_fail;
24481 }
24482 {
24483 #if wxUSE_UNICODE
24484 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24485 #else
24486 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24487 #endif
24488 }
24489 return resultobj;
24490 fail:
24491 return NULL;
24492 }
24493
24494
24495 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24496 PyObject *resultobj = NULL;
24497 bool arg1 ;
24498 PyObject * obj0 = 0 ;
24499 char *kwnames[] = {
24500 (char *) "val", NULL
24501 };
24502
24503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
24504 {
24505 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
24506 if (SWIG_arg_fail(1)) SWIG_fail;
24507 }
24508 {
24509 PyThreadState* __tstate = wxPyBeginAllowThreads();
24510 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
24511
24512 wxPyEndAllowThreads(__tstate);
24513 if (PyErr_Occurred()) SWIG_fail;
24514 }
24515 Py_INCREF(Py_None); resultobj = Py_None;
24516 return resultobj;
24517 fail:
24518 return NULL;
24519 }
24520
24521
24522 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24523 PyObject *resultobj = NULL;
24524 long arg1 ;
24525 PyObject * obj0 = 0 ;
24526 char *kwnames[] = {
24527 (char *) "val", NULL
24528 };
24529
24530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
24531 {
24532 arg1 = static_cast<long >(SWIG_As_long(obj0));
24533 if (SWIG_arg_fail(1)) SWIG_fail;
24534 }
24535 {
24536 PyThreadState* __tstate = wxPyBeginAllowThreads();
24537 wxPyApp::SetMacAboutMenuItemId(arg1);
24538
24539 wxPyEndAllowThreads(__tstate);
24540 if (PyErr_Occurred()) SWIG_fail;
24541 }
24542 Py_INCREF(Py_None); resultobj = Py_None;
24543 return resultobj;
24544 fail:
24545 return NULL;
24546 }
24547
24548
24549 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24550 PyObject *resultobj = NULL;
24551 long arg1 ;
24552 PyObject * obj0 = 0 ;
24553 char *kwnames[] = {
24554 (char *) "val", NULL
24555 };
24556
24557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
24558 {
24559 arg1 = static_cast<long >(SWIG_As_long(obj0));
24560 if (SWIG_arg_fail(1)) SWIG_fail;
24561 }
24562 {
24563 PyThreadState* __tstate = wxPyBeginAllowThreads();
24564 wxPyApp::SetMacPreferencesMenuItemId(arg1);
24565
24566 wxPyEndAllowThreads(__tstate);
24567 if (PyErr_Occurred()) SWIG_fail;
24568 }
24569 Py_INCREF(Py_None); resultobj = Py_None;
24570 return resultobj;
24571 fail:
24572 return NULL;
24573 }
24574
24575
24576 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24577 PyObject *resultobj = NULL;
24578 long arg1 ;
24579 PyObject * obj0 = 0 ;
24580 char *kwnames[] = {
24581 (char *) "val", NULL
24582 };
24583
24584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
24585 {
24586 arg1 = static_cast<long >(SWIG_As_long(obj0));
24587 if (SWIG_arg_fail(1)) SWIG_fail;
24588 }
24589 {
24590 PyThreadState* __tstate = wxPyBeginAllowThreads();
24591 wxPyApp::SetMacExitMenuItemId(arg1);
24592
24593 wxPyEndAllowThreads(__tstate);
24594 if (PyErr_Occurred()) SWIG_fail;
24595 }
24596 Py_INCREF(Py_None); resultobj = Py_None;
24597 return resultobj;
24598 fail:
24599 return NULL;
24600 }
24601
24602
24603 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24604 PyObject *resultobj = NULL;
24605 wxString *arg1 = 0 ;
24606 bool temp1 = false ;
24607 PyObject * obj0 = 0 ;
24608 char *kwnames[] = {
24609 (char *) "val", NULL
24610 };
24611
24612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
24613 {
24614 arg1 = wxString_in_helper(obj0);
24615 if (arg1 == NULL) SWIG_fail;
24616 temp1 = true;
24617 }
24618 {
24619 PyThreadState* __tstate = wxPyBeginAllowThreads();
24620 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
24621
24622 wxPyEndAllowThreads(__tstate);
24623 if (PyErr_Occurred()) SWIG_fail;
24624 }
24625 Py_INCREF(Py_None); resultobj = Py_None;
24626 {
24627 if (temp1)
24628 delete arg1;
24629 }
24630 return resultobj;
24631 fail:
24632 {
24633 if (temp1)
24634 delete arg1;
24635 }
24636 return NULL;
24637 }
24638
24639
24640 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
24641 PyObject *resultobj = NULL;
24642 wxPyApp *arg1 = (wxPyApp *) 0 ;
24643 PyObject * obj0 = 0 ;
24644 char *kwnames[] = {
24645 (char *) "self", NULL
24646 };
24647
24648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
24649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24650 if (SWIG_arg_fail(1)) SWIG_fail;
24651 {
24652 PyThreadState* __tstate = wxPyBeginAllowThreads();
24653 (arg1)->_BootstrapApp();
24654
24655 wxPyEndAllowThreads(__tstate);
24656 if (PyErr_Occurred()) SWIG_fail;
24657 }
24658 Py_INCREF(Py_None); resultobj = Py_None;
24659 return resultobj;
24660 fail:
24661 return NULL;
24662 }
24663
24664
24665 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
24666 PyObject *resultobj = NULL;
24667 int result;
24668 char *kwnames[] = {
24669 NULL
24670 };
24671
24672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
24673 {
24674 PyThreadState* __tstate = wxPyBeginAllowThreads();
24675 result = (int)wxPyApp_GetComCtl32Version();
24676
24677 wxPyEndAllowThreads(__tstate);
24678 if (PyErr_Occurred()) SWIG_fail;
24679 }
24680 {
24681 resultobj = SWIG_From_int(static_cast<int >(result));
24682 }
24683 return resultobj;
24684 fail:
24685 return NULL;
24686 }
24687
24688
24689 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
24690 PyObject *obj;
24691 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24692 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
24693 Py_INCREF(obj);
24694 return Py_BuildValue((char *)"");
24695 }
24696 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24697 PyObject *resultobj = NULL;
24698 char *kwnames[] = {
24699 NULL
24700 };
24701
24702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
24703 {
24704 PyThreadState* __tstate = wxPyBeginAllowThreads();
24705 wxExit();
24706
24707 wxPyEndAllowThreads(__tstate);
24708 if (PyErr_Occurred()) SWIG_fail;
24709 }
24710 Py_INCREF(Py_None); resultobj = Py_None;
24711 return resultobj;
24712 fail:
24713 return NULL;
24714 }
24715
24716
24717 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
24718 PyObject *resultobj = NULL;
24719 bool result;
24720 char *kwnames[] = {
24721 NULL
24722 };
24723
24724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
24725 {
24726 PyThreadState* __tstate = wxPyBeginAllowThreads();
24727 result = (bool)wxYield();
24728
24729 wxPyEndAllowThreads(__tstate);
24730 if (PyErr_Occurred()) SWIG_fail;
24731 }
24732 {
24733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24734 }
24735 return resultobj;
24736 fail:
24737 return NULL;
24738 }
24739
24740
24741 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
24742 PyObject *resultobj = NULL;
24743 bool result;
24744 char *kwnames[] = {
24745 NULL
24746 };
24747
24748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
24749 {
24750 PyThreadState* __tstate = wxPyBeginAllowThreads();
24751 result = (bool)wxYieldIfNeeded();
24752
24753 wxPyEndAllowThreads(__tstate);
24754 if (PyErr_Occurred()) SWIG_fail;
24755 }
24756 {
24757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24758 }
24759 return resultobj;
24760 fail:
24761 return NULL;
24762 }
24763
24764
24765 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
24766 PyObject *resultobj = NULL;
24767 wxWindow *arg1 = (wxWindow *) NULL ;
24768 bool arg2 = (bool) false ;
24769 bool result;
24770 PyObject * obj0 = 0 ;
24771 PyObject * obj1 = 0 ;
24772 char *kwnames[] = {
24773 (char *) "win",(char *) "onlyIfNeeded", NULL
24774 };
24775
24776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24777 if (obj0) {
24778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24779 if (SWIG_arg_fail(1)) SWIG_fail;
24780 }
24781 if (obj1) {
24782 {
24783 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24784 if (SWIG_arg_fail(2)) SWIG_fail;
24785 }
24786 }
24787 {
24788 PyThreadState* __tstate = wxPyBeginAllowThreads();
24789 result = (bool)wxSafeYield(arg1,arg2);
24790
24791 wxPyEndAllowThreads(__tstate);
24792 if (PyErr_Occurred()) SWIG_fail;
24793 }
24794 {
24795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24796 }
24797 return resultobj;
24798 fail:
24799 return NULL;
24800 }
24801
24802
24803 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24804 PyObject *resultobj = NULL;
24805 char *kwnames[] = {
24806 NULL
24807 };
24808
24809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24810 {
24811 PyThreadState* __tstate = wxPyBeginAllowThreads();
24812 wxWakeUpIdle();
24813
24814 wxPyEndAllowThreads(__tstate);
24815 if (PyErr_Occurred()) SWIG_fail;
24816 }
24817 Py_INCREF(Py_None); resultobj = Py_None;
24818 return resultobj;
24819 fail:
24820 return NULL;
24821 }
24822
24823
24824 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24825 PyObject *resultobj = NULL;
24826 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24827 wxEvent *arg2 = 0 ;
24828 PyObject * obj0 = 0 ;
24829 PyObject * obj1 = 0 ;
24830 char *kwnames[] = {
24831 (char *) "dest",(char *) "event", NULL
24832 };
24833
24834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24836 if (SWIG_arg_fail(1)) SWIG_fail;
24837 {
24838 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24839 if (SWIG_arg_fail(2)) SWIG_fail;
24840 if (arg2 == NULL) {
24841 SWIG_null_ref("wxEvent");
24842 }
24843 if (SWIG_arg_fail(2)) SWIG_fail;
24844 }
24845 {
24846 PyThreadState* __tstate = wxPyBeginAllowThreads();
24847 wxPostEvent(arg1,*arg2);
24848
24849 wxPyEndAllowThreads(__tstate);
24850 if (PyErr_Occurred()) SWIG_fail;
24851 }
24852 Py_INCREF(Py_None); resultobj = Py_None;
24853 return resultobj;
24854 fail:
24855 return NULL;
24856 }
24857
24858
24859 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24860 PyObject *resultobj = NULL;
24861 char *kwnames[] = {
24862 NULL
24863 };
24864
24865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24866 {
24867 PyThreadState* __tstate = wxPyBeginAllowThreads();
24868 wxApp_CleanUp();
24869
24870 wxPyEndAllowThreads(__tstate);
24871 if (PyErr_Occurred()) SWIG_fail;
24872 }
24873 Py_INCREF(Py_None); resultobj = Py_None;
24874 return resultobj;
24875 fail:
24876 return NULL;
24877 }
24878
24879
24880 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24881 PyObject *resultobj = NULL;
24882 wxPyApp *result;
24883 char *kwnames[] = {
24884 NULL
24885 };
24886
24887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24888 {
24889 PyThreadState* __tstate = wxPyBeginAllowThreads();
24890 result = (wxPyApp *)wxPyGetApp();
24891
24892 wxPyEndAllowThreads(__tstate);
24893 if (PyErr_Occurred()) SWIG_fail;
24894 }
24895 {
24896 resultobj = wxPyMake_wxObject(result, 0);
24897 }
24898 return resultobj;
24899 fail:
24900 return NULL;
24901 }
24902
24903
24904 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24905 PyObject *resultobj = NULL;
24906 char *arg1 = (char *) 0 ;
24907 PyObject * obj0 = 0 ;
24908 char *kwnames[] = {
24909 (char *) "encoding", NULL
24910 };
24911
24912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24913 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24914 SWIG_arg_fail(1);SWIG_fail;
24915 }
24916 {
24917 PyThreadState* __tstate = wxPyBeginAllowThreads();
24918 wxSetDefaultPyEncoding((char const *)arg1);
24919
24920 wxPyEndAllowThreads(__tstate);
24921 if (PyErr_Occurred()) SWIG_fail;
24922 }
24923 Py_INCREF(Py_None); resultobj = Py_None;
24924 return resultobj;
24925 fail:
24926 return NULL;
24927 }
24928
24929
24930 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24931 PyObject *resultobj = NULL;
24932 char *result;
24933 char *kwnames[] = {
24934 NULL
24935 };
24936
24937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24938 {
24939 PyThreadState* __tstate = wxPyBeginAllowThreads();
24940 result = (char *)wxGetDefaultPyEncoding();
24941
24942 wxPyEndAllowThreads(__tstate);
24943 if (PyErr_Occurred()) SWIG_fail;
24944 }
24945 resultobj = SWIG_FromCharPtr(result);
24946 return resultobj;
24947 fail:
24948 return NULL;
24949 }
24950
24951
24952 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24953 PyObject *resultobj = NULL;
24954 wxEventLoop *result;
24955 char *kwnames[] = {
24956 NULL
24957 };
24958
24959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24960 {
24961 PyThreadState* __tstate = wxPyBeginAllowThreads();
24962 result = (wxEventLoop *)new wxEventLoop();
24963
24964 wxPyEndAllowThreads(__tstate);
24965 if (PyErr_Occurred()) SWIG_fail;
24966 }
24967 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24968 return resultobj;
24969 fail:
24970 return NULL;
24971 }
24972
24973
24974 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24975 PyObject *resultobj = NULL;
24976 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24977 PyObject * obj0 = 0 ;
24978 char *kwnames[] = {
24979 (char *) "self", NULL
24980 };
24981
24982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24984 if (SWIG_arg_fail(1)) SWIG_fail;
24985 {
24986 PyThreadState* __tstate = wxPyBeginAllowThreads();
24987 delete arg1;
24988
24989 wxPyEndAllowThreads(__tstate);
24990 if (PyErr_Occurred()) SWIG_fail;
24991 }
24992 Py_INCREF(Py_None); resultobj = Py_None;
24993 return resultobj;
24994 fail:
24995 return NULL;
24996 }
24997
24998
24999 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
25000 PyObject *resultobj = NULL;
25001 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25002 int result;
25003 PyObject * obj0 = 0 ;
25004 char *kwnames[] = {
25005 (char *) "self", NULL
25006 };
25007
25008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
25009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25010 if (SWIG_arg_fail(1)) SWIG_fail;
25011 {
25012 PyThreadState* __tstate = wxPyBeginAllowThreads();
25013 result = (int)(arg1)->Run();
25014
25015 wxPyEndAllowThreads(__tstate);
25016 if (PyErr_Occurred()) SWIG_fail;
25017 }
25018 {
25019 resultobj = SWIG_From_int(static_cast<int >(result));
25020 }
25021 return resultobj;
25022 fail:
25023 return NULL;
25024 }
25025
25026
25027 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
25028 PyObject *resultobj = NULL;
25029 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25030 int arg2 = (int) 0 ;
25031 PyObject * obj0 = 0 ;
25032 PyObject * obj1 = 0 ;
25033 char *kwnames[] = {
25034 (char *) "self",(char *) "rc", NULL
25035 };
25036
25037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
25038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25039 if (SWIG_arg_fail(1)) SWIG_fail;
25040 if (obj1) {
25041 {
25042 arg2 = static_cast<int >(SWIG_As_int(obj1));
25043 if (SWIG_arg_fail(2)) SWIG_fail;
25044 }
25045 }
25046 {
25047 PyThreadState* __tstate = wxPyBeginAllowThreads();
25048 (arg1)->Exit(arg2);
25049
25050 wxPyEndAllowThreads(__tstate);
25051 if (PyErr_Occurred()) SWIG_fail;
25052 }
25053 Py_INCREF(Py_None); resultobj = Py_None;
25054 return resultobj;
25055 fail:
25056 return NULL;
25057 }
25058
25059
25060 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
25061 PyObject *resultobj = NULL;
25062 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25063 bool result;
25064 PyObject * obj0 = 0 ;
25065 char *kwnames[] = {
25066 (char *) "self", NULL
25067 };
25068
25069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
25070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25071 if (SWIG_arg_fail(1)) SWIG_fail;
25072 {
25073 PyThreadState* __tstate = wxPyBeginAllowThreads();
25074 result = (bool)((wxEventLoop const *)arg1)->Pending();
25075
25076 wxPyEndAllowThreads(__tstate);
25077 if (PyErr_Occurred()) SWIG_fail;
25078 }
25079 {
25080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25081 }
25082 return resultobj;
25083 fail:
25084 return NULL;
25085 }
25086
25087
25088 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
25089 PyObject *resultobj = NULL;
25090 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25091 bool result;
25092 PyObject * obj0 = 0 ;
25093 char *kwnames[] = {
25094 (char *) "self", NULL
25095 };
25096
25097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
25098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25099 if (SWIG_arg_fail(1)) SWIG_fail;
25100 {
25101 PyThreadState* __tstate = wxPyBeginAllowThreads();
25102 result = (bool)(arg1)->Dispatch();
25103
25104 wxPyEndAllowThreads(__tstate);
25105 if (PyErr_Occurred()) SWIG_fail;
25106 }
25107 {
25108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25109 }
25110 return resultobj;
25111 fail:
25112 return NULL;
25113 }
25114
25115
25116 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
25117 PyObject *resultobj = NULL;
25118 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25119 bool result;
25120 PyObject * obj0 = 0 ;
25121 char *kwnames[] = {
25122 (char *) "self", NULL
25123 };
25124
25125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
25126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25127 if (SWIG_arg_fail(1)) SWIG_fail;
25128 {
25129 PyThreadState* __tstate = wxPyBeginAllowThreads();
25130 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
25131
25132 wxPyEndAllowThreads(__tstate);
25133 if (PyErr_Occurred()) SWIG_fail;
25134 }
25135 {
25136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25137 }
25138 return resultobj;
25139 fail:
25140 return NULL;
25141 }
25142
25143
25144 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
25145 PyObject *resultobj = NULL;
25146 wxEventLoop *result;
25147 char *kwnames[] = {
25148 NULL
25149 };
25150
25151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
25152 {
25153 PyThreadState* __tstate = wxPyBeginAllowThreads();
25154 result = (wxEventLoop *)wxEventLoop::GetActive();
25155
25156 wxPyEndAllowThreads(__tstate);
25157 if (PyErr_Occurred()) SWIG_fail;
25158 }
25159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
25160 return resultobj;
25161 fail:
25162 return NULL;
25163 }
25164
25165
25166 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
25167 PyObject *resultobj = NULL;
25168 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25169 PyObject * obj0 = 0 ;
25170 char *kwnames[] = {
25171 (char *) "loop", NULL
25172 };
25173
25174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
25175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25176 if (SWIG_arg_fail(1)) SWIG_fail;
25177 {
25178 PyThreadState* __tstate = wxPyBeginAllowThreads();
25179 wxEventLoop::SetActive(arg1);
25180
25181 wxPyEndAllowThreads(__tstate);
25182 if (PyErr_Occurred()) SWIG_fail;
25183 }
25184 Py_INCREF(Py_None); resultobj = Py_None;
25185 return resultobj;
25186 fail:
25187 return NULL;
25188 }
25189
25190
25191 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
25192 PyObject *obj;
25193 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25194 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
25195 Py_INCREF(obj);
25196 return Py_BuildValue((char *)"");
25197 }
25198 static PyObject *_wrap_new_EventLoopActivator(PyObject *, PyObject *args, PyObject *kwargs) {
25199 PyObject *resultobj = NULL;
25200 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25201 wxEventLoopActivator *result;
25202 PyObject * obj0 = 0 ;
25203 char *kwnames[] = {
25204 (char *) "evtLoop", NULL
25205 };
25206
25207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) goto fail;
25208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25209 if (SWIG_arg_fail(1)) SWIG_fail;
25210 {
25211 PyThreadState* __tstate = wxPyBeginAllowThreads();
25212 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
25213
25214 wxPyEndAllowThreads(__tstate);
25215 if (PyErr_Occurred()) SWIG_fail;
25216 }
25217 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoopActivator, 1);
25218 return resultobj;
25219 fail:
25220 return NULL;
25221 }
25222
25223
25224 static PyObject *_wrap_delete_EventLoopActivator(PyObject *, PyObject *args, PyObject *kwargs) {
25225 PyObject *resultobj = NULL;
25226 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
25227 PyObject * obj0 = 0 ;
25228 char *kwnames[] = {
25229 (char *) "self", NULL
25230 };
25231
25232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoopActivator",kwnames,&obj0)) goto fail;
25233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_EXCEPTION | 0);
25234 if (SWIG_arg_fail(1)) SWIG_fail;
25235 {
25236 PyThreadState* __tstate = wxPyBeginAllowThreads();
25237 delete arg1;
25238
25239 wxPyEndAllowThreads(__tstate);
25240 if (PyErr_Occurred()) SWIG_fail;
25241 }
25242 Py_INCREF(Py_None); resultobj = Py_None;
25243 return resultobj;
25244 fail:
25245 return NULL;
25246 }
25247
25248
25249 static PyObject * EventLoopActivator_swigregister(PyObject *, PyObject *args) {
25250 PyObject *obj;
25251 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25252 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoopActivator, obj);
25253 Py_INCREF(obj);
25254 return Py_BuildValue((char *)"");
25255 }
25256 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25257 PyObject *resultobj = NULL;
25258 int arg1 = (int) 0 ;
25259 int arg2 = (int) 0 ;
25260 int arg3 = (int) 0 ;
25261 wxAcceleratorEntry *result;
25262 PyObject * obj0 = 0 ;
25263 PyObject * obj1 = 0 ;
25264 PyObject * obj2 = 0 ;
25265 char *kwnames[] = {
25266 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
25267 };
25268
25269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
25270 if (obj0) {
25271 {
25272 arg1 = static_cast<int >(SWIG_As_int(obj0));
25273 if (SWIG_arg_fail(1)) SWIG_fail;
25274 }
25275 }
25276 if (obj1) {
25277 {
25278 arg2 = static_cast<int >(SWIG_As_int(obj1));
25279 if (SWIG_arg_fail(2)) SWIG_fail;
25280 }
25281 }
25282 if (obj2) {
25283 {
25284 arg3 = static_cast<int >(SWIG_As_int(obj2));
25285 if (SWIG_arg_fail(3)) SWIG_fail;
25286 }
25287 }
25288 {
25289 PyThreadState* __tstate = wxPyBeginAllowThreads();
25290 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
25291
25292 wxPyEndAllowThreads(__tstate);
25293 if (PyErr_Occurred()) SWIG_fail;
25294 }
25295 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
25296 return resultobj;
25297 fail:
25298 return NULL;
25299 }
25300
25301
25302 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25303 PyObject *resultobj = NULL;
25304 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25305 PyObject * obj0 = 0 ;
25306 char *kwnames[] = {
25307 (char *) "self", NULL
25308 };
25309
25310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
25311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25312 if (SWIG_arg_fail(1)) SWIG_fail;
25313 {
25314 PyThreadState* __tstate = wxPyBeginAllowThreads();
25315 delete arg1;
25316
25317 wxPyEndAllowThreads(__tstate);
25318 if (PyErr_Occurred()) SWIG_fail;
25319 }
25320 Py_INCREF(Py_None); resultobj = Py_None;
25321 return resultobj;
25322 fail:
25323 return NULL;
25324 }
25325
25326
25327 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
25328 PyObject *resultobj = NULL;
25329 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25330 int arg2 ;
25331 int arg3 ;
25332 int arg4 ;
25333 PyObject * obj0 = 0 ;
25334 PyObject * obj1 = 0 ;
25335 PyObject * obj2 = 0 ;
25336 PyObject * obj3 = 0 ;
25337 char *kwnames[] = {
25338 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
25339 };
25340
25341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25343 if (SWIG_arg_fail(1)) SWIG_fail;
25344 {
25345 arg2 = static_cast<int >(SWIG_As_int(obj1));
25346 if (SWIG_arg_fail(2)) SWIG_fail;
25347 }
25348 {
25349 arg3 = static_cast<int >(SWIG_As_int(obj2));
25350 if (SWIG_arg_fail(3)) SWIG_fail;
25351 }
25352 {
25353 arg4 = static_cast<int >(SWIG_As_int(obj3));
25354 if (SWIG_arg_fail(4)) SWIG_fail;
25355 }
25356 {
25357 PyThreadState* __tstate = wxPyBeginAllowThreads();
25358 (arg1)->Set(arg2,arg3,arg4);
25359
25360 wxPyEndAllowThreads(__tstate);
25361 if (PyErr_Occurred()) SWIG_fail;
25362 }
25363 Py_INCREF(Py_None); resultobj = Py_None;
25364 return resultobj;
25365 fail:
25366 return NULL;
25367 }
25368
25369
25370 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
25371 PyObject *resultobj = NULL;
25372 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25373 int result;
25374 PyObject * obj0 = 0 ;
25375 char *kwnames[] = {
25376 (char *) "self", NULL
25377 };
25378
25379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
25380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25381 if (SWIG_arg_fail(1)) SWIG_fail;
25382 {
25383 PyThreadState* __tstate = wxPyBeginAllowThreads();
25384 result = (int)(arg1)->GetFlags();
25385
25386 wxPyEndAllowThreads(__tstate);
25387 if (PyErr_Occurred()) SWIG_fail;
25388 }
25389 {
25390 resultobj = SWIG_From_int(static_cast<int >(result));
25391 }
25392 return resultobj;
25393 fail:
25394 return NULL;
25395 }
25396
25397
25398 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
25399 PyObject *resultobj = NULL;
25400 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25401 int result;
25402 PyObject * obj0 = 0 ;
25403 char *kwnames[] = {
25404 (char *) "self", NULL
25405 };
25406
25407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
25408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25409 if (SWIG_arg_fail(1)) SWIG_fail;
25410 {
25411 PyThreadState* __tstate = wxPyBeginAllowThreads();
25412 result = (int)(arg1)->GetKeyCode();
25413
25414 wxPyEndAllowThreads(__tstate);
25415 if (PyErr_Occurred()) SWIG_fail;
25416 }
25417 {
25418 resultobj = SWIG_From_int(static_cast<int >(result));
25419 }
25420 return resultobj;
25421 fail:
25422 return NULL;
25423 }
25424
25425
25426 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
25427 PyObject *resultobj = NULL;
25428 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25429 int result;
25430 PyObject * obj0 = 0 ;
25431 char *kwnames[] = {
25432 (char *) "self", NULL
25433 };
25434
25435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
25436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25437 if (SWIG_arg_fail(1)) SWIG_fail;
25438 {
25439 PyThreadState* __tstate = wxPyBeginAllowThreads();
25440 result = (int)(arg1)->GetCommand();
25441
25442 wxPyEndAllowThreads(__tstate);
25443 if (PyErr_Occurred()) SWIG_fail;
25444 }
25445 {
25446 resultobj = SWIG_From_int(static_cast<int >(result));
25447 }
25448 return resultobj;
25449 fail:
25450 return NULL;
25451 }
25452
25453
25454 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
25455 PyObject *obj;
25456 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25457 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
25458 Py_INCREF(obj);
25459 return Py_BuildValue((char *)"");
25460 }
25461 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25462 PyObject *resultobj = NULL;
25463 int arg1 ;
25464 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
25465 wxAcceleratorTable *result;
25466 PyObject * obj0 = 0 ;
25467 char *kwnames[] = {
25468 (char *) "n", NULL
25469 };
25470
25471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
25472 {
25473 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
25474 if (arg2) arg1 = PyList_Size(obj0);
25475 else arg1 = 0;
25476 }
25477 {
25478 PyThreadState* __tstate = wxPyBeginAllowThreads();
25479 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
25480
25481 wxPyEndAllowThreads(__tstate);
25482 if (PyErr_Occurred()) SWIG_fail;
25483 }
25484 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
25485 {
25486 delete [] arg2;
25487 }
25488 return resultobj;
25489 fail:
25490 {
25491 delete [] arg2;
25492 }
25493 return NULL;
25494 }
25495
25496
25497 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25498 PyObject *resultobj = NULL;
25499 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25500 PyObject * obj0 = 0 ;
25501 char *kwnames[] = {
25502 (char *) "self", NULL
25503 };
25504
25505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
25506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25507 if (SWIG_arg_fail(1)) SWIG_fail;
25508 {
25509 PyThreadState* __tstate = wxPyBeginAllowThreads();
25510 delete arg1;
25511
25512 wxPyEndAllowThreads(__tstate);
25513 if (PyErr_Occurred()) SWIG_fail;
25514 }
25515 Py_INCREF(Py_None); resultobj = Py_None;
25516 return resultobj;
25517 fail:
25518 return NULL;
25519 }
25520
25521
25522 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
25523 PyObject *resultobj = NULL;
25524 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25525 bool result;
25526 PyObject * obj0 = 0 ;
25527 char *kwnames[] = {
25528 (char *) "self", NULL
25529 };
25530
25531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
25532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25533 if (SWIG_arg_fail(1)) SWIG_fail;
25534 {
25535 PyThreadState* __tstate = wxPyBeginAllowThreads();
25536 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
25537
25538 wxPyEndAllowThreads(__tstate);
25539 if (PyErr_Occurred()) SWIG_fail;
25540 }
25541 {
25542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25543 }
25544 return resultobj;
25545 fail:
25546 return NULL;
25547 }
25548
25549
25550 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
25551 PyObject *obj;
25552 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25553 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
25554 Py_INCREF(obj);
25555 return Py_BuildValue((char *)"");
25556 }
25557 static int _wrap_NullAcceleratorTable_set(PyObject *) {
25558 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
25559 return 1;
25560 }
25561
25562
25563 static PyObject *_wrap_NullAcceleratorTable_get(void) {
25564 PyObject *pyobj = NULL;
25565
25566 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
25567 return pyobj;
25568 }
25569
25570
25571 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
25572 PyObject *resultobj = NULL;
25573 wxString *arg1 = 0 ;
25574 wxAcceleratorEntry *result;
25575 bool temp1 = false ;
25576 PyObject * obj0 = 0 ;
25577 char *kwnames[] = {
25578 (char *) "label", NULL
25579 };
25580
25581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
25582 {
25583 arg1 = wxString_in_helper(obj0);
25584 if (arg1 == NULL) SWIG_fail;
25585 temp1 = true;
25586 }
25587 {
25588 PyThreadState* __tstate = wxPyBeginAllowThreads();
25589 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
25590
25591 wxPyEndAllowThreads(__tstate);
25592 if (PyErr_Occurred()) SWIG_fail;
25593 }
25594 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
25595 {
25596 if (temp1)
25597 delete arg1;
25598 }
25599 return resultobj;
25600 fail:
25601 {
25602 if (temp1)
25603 delete arg1;
25604 }
25605 return NULL;
25606 }
25607
25608
25609 static int _wrap_PanelNameStr_set(PyObject *) {
25610 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
25611 return 1;
25612 }
25613
25614
25615 static PyObject *_wrap_PanelNameStr_get(void) {
25616 PyObject *pyobj = NULL;
25617
25618 {
25619 #if wxUSE_UNICODE
25620 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25621 #else
25622 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25623 #endif
25624 }
25625 return pyobj;
25626 }
25627
25628
25629 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25630 PyObject *resultobj = NULL;
25631 wxVisualAttributes *result;
25632 char *kwnames[] = {
25633 NULL
25634 };
25635
25636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
25637 {
25638 PyThreadState* __tstate = wxPyBeginAllowThreads();
25639 result = (wxVisualAttributes *)new_wxVisualAttributes();
25640
25641 wxPyEndAllowThreads(__tstate);
25642 if (PyErr_Occurred()) SWIG_fail;
25643 }
25644 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
25645 return resultobj;
25646 fail:
25647 return NULL;
25648 }
25649
25650
25651 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25652 PyObject *resultobj = NULL;
25653 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25654 PyObject * obj0 = 0 ;
25655 char *kwnames[] = {
25656 (char *) "self", NULL
25657 };
25658
25659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
25660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25661 if (SWIG_arg_fail(1)) SWIG_fail;
25662 {
25663 PyThreadState* __tstate = wxPyBeginAllowThreads();
25664 delete_wxVisualAttributes(arg1);
25665
25666 wxPyEndAllowThreads(__tstate);
25667 if (PyErr_Occurred()) SWIG_fail;
25668 }
25669 Py_INCREF(Py_None); resultobj = Py_None;
25670 return resultobj;
25671 fail:
25672 return NULL;
25673 }
25674
25675
25676 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
25677 PyObject *resultobj = NULL;
25678 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25679 wxFont *arg2 = (wxFont *) 0 ;
25680 PyObject * obj0 = 0 ;
25681 PyObject * obj1 = 0 ;
25682 char *kwnames[] = {
25683 (char *) "self",(char *) "font", NULL
25684 };
25685
25686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
25687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25688 if (SWIG_arg_fail(1)) SWIG_fail;
25689 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
25690 if (SWIG_arg_fail(2)) SWIG_fail;
25691 if (arg1) (arg1)->font = *arg2;
25692
25693 Py_INCREF(Py_None); resultobj = Py_None;
25694 return resultobj;
25695 fail:
25696 return NULL;
25697 }
25698
25699
25700 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
25701 PyObject *resultobj = NULL;
25702 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25703 wxFont *result;
25704 PyObject * obj0 = 0 ;
25705 char *kwnames[] = {
25706 (char *) "self", NULL
25707 };
25708
25709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
25710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25711 if (SWIG_arg_fail(1)) SWIG_fail;
25712 result = (wxFont *)& ((arg1)->font);
25713
25714 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
25715 return resultobj;
25716 fail:
25717 return NULL;
25718 }
25719
25720
25721 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25722 PyObject *resultobj = NULL;
25723 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25724 wxColour *arg2 = (wxColour *) 0 ;
25725 PyObject * obj0 = 0 ;
25726 PyObject * obj1 = 0 ;
25727 char *kwnames[] = {
25728 (char *) "self",(char *) "colFg", NULL
25729 };
25730
25731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
25732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25733 if (SWIG_arg_fail(1)) SWIG_fail;
25734 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25735 if (SWIG_arg_fail(2)) SWIG_fail;
25736 if (arg1) (arg1)->colFg = *arg2;
25737
25738 Py_INCREF(Py_None); resultobj = Py_None;
25739 return resultobj;
25740 fail:
25741 return NULL;
25742 }
25743
25744
25745 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25746 PyObject *resultobj = NULL;
25747 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25748 wxColour *result;
25749 PyObject * obj0 = 0 ;
25750 char *kwnames[] = {
25751 (char *) "self", NULL
25752 };
25753
25754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
25755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25756 if (SWIG_arg_fail(1)) SWIG_fail;
25757 result = (wxColour *)& ((arg1)->colFg);
25758
25759 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25760 return resultobj;
25761 fail:
25762 return NULL;
25763 }
25764
25765
25766 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25767 PyObject *resultobj = NULL;
25768 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25769 wxColour *arg2 = (wxColour *) 0 ;
25770 PyObject * obj0 = 0 ;
25771 PyObject * obj1 = 0 ;
25772 char *kwnames[] = {
25773 (char *) "self",(char *) "colBg", NULL
25774 };
25775
25776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
25777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25778 if (SWIG_arg_fail(1)) SWIG_fail;
25779 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25780 if (SWIG_arg_fail(2)) SWIG_fail;
25781 if (arg1) (arg1)->colBg = *arg2;
25782
25783 Py_INCREF(Py_None); resultobj = Py_None;
25784 return resultobj;
25785 fail:
25786 return NULL;
25787 }
25788
25789
25790 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25791 PyObject *resultobj = NULL;
25792 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25793 wxColour *result;
25794 PyObject * obj0 = 0 ;
25795 char *kwnames[] = {
25796 (char *) "self", NULL
25797 };
25798
25799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
25800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25801 if (SWIG_arg_fail(1)) SWIG_fail;
25802 result = (wxColour *)& ((arg1)->colBg);
25803
25804 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25805 return resultobj;
25806 fail:
25807 return NULL;
25808 }
25809
25810
25811 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
25812 PyObject *obj;
25813 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25814 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
25815 Py_INCREF(obj);
25816 return Py_BuildValue((char *)"");
25817 }
25818 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
25819 PyObject *resultobj = NULL;
25820 wxWindow *arg1 = (wxWindow *) 0 ;
25821 int arg2 = (int) (int)-1 ;
25822 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25823 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25824 wxSize const &arg4_defvalue = wxDefaultSize ;
25825 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25826 long arg5 = (long) 0 ;
25827 wxString const &arg6_defvalue = wxPyPanelNameStr ;
25828 wxString *arg6 = (wxString *) &arg6_defvalue ;
25829 wxWindow *result;
25830 wxPoint temp3 ;
25831 wxSize temp4 ;
25832 bool temp6 = false ;
25833 PyObject * obj0 = 0 ;
25834 PyObject * obj1 = 0 ;
25835 PyObject * obj2 = 0 ;
25836 PyObject * obj3 = 0 ;
25837 PyObject * obj4 = 0 ;
25838 PyObject * obj5 = 0 ;
25839 char *kwnames[] = {
25840 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25841 };
25842
25843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25845 if (SWIG_arg_fail(1)) SWIG_fail;
25846 if (obj1) {
25847 {
25848 arg2 = static_cast<int const >(SWIG_As_int(obj1));
25849 if (SWIG_arg_fail(2)) SWIG_fail;
25850 }
25851 }
25852 if (obj2) {
25853 {
25854 arg3 = &temp3;
25855 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25856 }
25857 }
25858 if (obj3) {
25859 {
25860 arg4 = &temp4;
25861 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25862 }
25863 }
25864 if (obj4) {
25865 {
25866 arg5 = static_cast<long >(SWIG_As_long(obj4));
25867 if (SWIG_arg_fail(5)) SWIG_fail;
25868 }
25869 }
25870 if (obj5) {
25871 {
25872 arg6 = wxString_in_helper(obj5);
25873 if (arg6 == NULL) SWIG_fail;
25874 temp6 = true;
25875 }
25876 }
25877 {
25878 if (!wxPyCheckForApp()) SWIG_fail;
25879 PyThreadState* __tstate = wxPyBeginAllowThreads();
25880 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25881
25882 wxPyEndAllowThreads(__tstate);
25883 if (PyErr_Occurred()) SWIG_fail;
25884 }
25885 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25886 {
25887 if (temp6)
25888 delete arg6;
25889 }
25890 return resultobj;
25891 fail:
25892 {
25893 if (temp6)
25894 delete arg6;
25895 }
25896 return NULL;
25897 }
25898
25899
25900 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25901 PyObject *resultobj = NULL;
25902 wxWindow *result;
25903 char *kwnames[] = {
25904 NULL
25905 };
25906
25907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25908 {
25909 if (!wxPyCheckForApp()) SWIG_fail;
25910 PyThreadState* __tstate = wxPyBeginAllowThreads();
25911 result = (wxWindow *)new wxWindow();
25912
25913 wxPyEndAllowThreads(__tstate);
25914 if (PyErr_Occurred()) SWIG_fail;
25915 }
25916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25917 return resultobj;
25918 fail:
25919 return NULL;
25920 }
25921
25922
25923 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25924 PyObject *resultobj = NULL;
25925 wxWindow *arg1 = (wxWindow *) 0 ;
25926 wxWindow *arg2 = (wxWindow *) 0 ;
25927 int arg3 = (int) (int)-1 ;
25928 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25929 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25930 wxSize const &arg5_defvalue = wxDefaultSize ;
25931 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25932 long arg6 = (long) 0 ;
25933 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25934 wxString *arg7 = (wxString *) &arg7_defvalue ;
25935 bool result;
25936 wxPoint temp4 ;
25937 wxSize temp5 ;
25938 bool temp7 = false ;
25939 PyObject * obj0 = 0 ;
25940 PyObject * obj1 = 0 ;
25941 PyObject * obj2 = 0 ;
25942 PyObject * obj3 = 0 ;
25943 PyObject * obj4 = 0 ;
25944 PyObject * obj5 = 0 ;
25945 PyObject * obj6 = 0 ;
25946 char *kwnames[] = {
25947 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25948 };
25949
25950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25952 if (SWIG_arg_fail(1)) SWIG_fail;
25953 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25954 if (SWIG_arg_fail(2)) SWIG_fail;
25955 if (obj2) {
25956 {
25957 arg3 = static_cast<int const >(SWIG_As_int(obj2));
25958 if (SWIG_arg_fail(3)) SWIG_fail;
25959 }
25960 }
25961 if (obj3) {
25962 {
25963 arg4 = &temp4;
25964 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25965 }
25966 }
25967 if (obj4) {
25968 {
25969 arg5 = &temp5;
25970 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25971 }
25972 }
25973 if (obj5) {
25974 {
25975 arg6 = static_cast<long >(SWIG_As_long(obj5));
25976 if (SWIG_arg_fail(6)) SWIG_fail;
25977 }
25978 }
25979 if (obj6) {
25980 {
25981 arg7 = wxString_in_helper(obj6);
25982 if (arg7 == NULL) SWIG_fail;
25983 temp7 = true;
25984 }
25985 }
25986 {
25987 PyThreadState* __tstate = wxPyBeginAllowThreads();
25988 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25989
25990 wxPyEndAllowThreads(__tstate);
25991 if (PyErr_Occurred()) SWIG_fail;
25992 }
25993 {
25994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25995 }
25996 {
25997 if (temp7)
25998 delete arg7;
25999 }
26000 return resultobj;
26001 fail:
26002 {
26003 if (temp7)
26004 delete arg7;
26005 }
26006 return NULL;
26007 }
26008
26009
26010 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
26011 PyObject *resultobj = NULL;
26012 wxWindow *arg1 = (wxWindow *) 0 ;
26013 bool arg2 = (bool) false ;
26014 bool result;
26015 PyObject * obj0 = 0 ;
26016 PyObject * obj1 = 0 ;
26017 char *kwnames[] = {
26018 (char *) "self",(char *) "force", NULL
26019 };
26020
26021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
26022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26023 if (SWIG_arg_fail(1)) SWIG_fail;
26024 if (obj1) {
26025 {
26026 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
26027 if (SWIG_arg_fail(2)) SWIG_fail;
26028 }
26029 }
26030 {
26031 PyThreadState* __tstate = wxPyBeginAllowThreads();
26032 result = (bool)(arg1)->Close(arg2);
26033
26034 wxPyEndAllowThreads(__tstate);
26035 if (PyErr_Occurred()) SWIG_fail;
26036 }
26037 {
26038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26039 }
26040 return resultobj;
26041 fail:
26042 return NULL;
26043 }
26044
26045
26046 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
26047 PyObject *resultobj = NULL;
26048 wxWindow *arg1 = (wxWindow *) 0 ;
26049 bool result;
26050 PyObject * obj0 = 0 ;
26051 char *kwnames[] = {
26052 (char *) "self", NULL
26053 };
26054
26055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
26056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26057 if (SWIG_arg_fail(1)) SWIG_fail;
26058 {
26059 PyThreadState* __tstate = wxPyBeginAllowThreads();
26060 result = (bool)(arg1)->Destroy();
26061
26062 wxPyEndAllowThreads(__tstate);
26063 if (PyErr_Occurred()) SWIG_fail;
26064 }
26065 {
26066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26067 }
26068 return resultobj;
26069 fail:
26070 return NULL;
26071 }
26072
26073
26074 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
26075 PyObject *resultobj = NULL;
26076 wxWindow *arg1 = (wxWindow *) 0 ;
26077 bool result;
26078 PyObject * obj0 = 0 ;
26079 char *kwnames[] = {
26080 (char *) "self", NULL
26081 };
26082
26083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
26084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26085 if (SWIG_arg_fail(1)) SWIG_fail;
26086 {
26087 PyThreadState* __tstate = wxPyBeginAllowThreads();
26088 result = (bool)(arg1)->DestroyChildren();
26089
26090 wxPyEndAllowThreads(__tstate);
26091 if (PyErr_Occurred()) SWIG_fail;
26092 }
26093 {
26094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26095 }
26096 return resultobj;
26097 fail:
26098 return NULL;
26099 }
26100
26101
26102 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
26103 PyObject *resultobj = NULL;
26104 wxWindow *arg1 = (wxWindow *) 0 ;
26105 bool result;
26106 PyObject * obj0 = 0 ;
26107 char *kwnames[] = {
26108 (char *) "self", NULL
26109 };
26110
26111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
26112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26113 if (SWIG_arg_fail(1)) SWIG_fail;
26114 {
26115 PyThreadState* __tstate = wxPyBeginAllowThreads();
26116 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
26117
26118 wxPyEndAllowThreads(__tstate);
26119 if (PyErr_Occurred()) SWIG_fail;
26120 }
26121 {
26122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26123 }
26124 return resultobj;
26125 fail:
26126 return NULL;
26127 }
26128
26129
26130 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
26131 PyObject *resultobj = NULL;
26132 wxWindow *arg1 = (wxWindow *) 0 ;
26133 wxString *arg2 = 0 ;
26134 bool temp2 = false ;
26135 PyObject * obj0 = 0 ;
26136 PyObject * obj1 = 0 ;
26137 char *kwnames[] = {
26138 (char *) "self",(char *) "label", NULL
26139 };
26140
26141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
26142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26143 if (SWIG_arg_fail(1)) SWIG_fail;
26144 {
26145 arg2 = wxString_in_helper(obj1);
26146 if (arg2 == NULL) SWIG_fail;
26147 temp2 = true;
26148 }
26149 {
26150 PyThreadState* __tstate = wxPyBeginAllowThreads();
26151 (arg1)->SetLabel((wxString const &)*arg2);
26152
26153 wxPyEndAllowThreads(__tstate);
26154 if (PyErr_Occurred()) SWIG_fail;
26155 }
26156 Py_INCREF(Py_None); resultobj = Py_None;
26157 {
26158 if (temp2)
26159 delete arg2;
26160 }
26161 return resultobj;
26162 fail:
26163 {
26164 if (temp2)
26165 delete arg2;
26166 }
26167 return NULL;
26168 }
26169
26170
26171 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
26172 PyObject *resultobj = NULL;
26173 wxWindow *arg1 = (wxWindow *) 0 ;
26174 wxString result;
26175 PyObject * obj0 = 0 ;
26176 char *kwnames[] = {
26177 (char *) "self", NULL
26178 };
26179
26180 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
26181 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26182 if (SWIG_arg_fail(1)) SWIG_fail;
26183 {
26184 PyThreadState* __tstate = wxPyBeginAllowThreads();
26185 result = ((wxWindow const *)arg1)->GetLabel();
26186
26187 wxPyEndAllowThreads(__tstate);
26188 if (PyErr_Occurred()) SWIG_fail;
26189 }
26190 {
26191 #if wxUSE_UNICODE
26192 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26193 #else
26194 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26195 #endif
26196 }
26197 return resultobj;
26198 fail:
26199 return NULL;
26200 }
26201
26202
26203 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
26204 PyObject *resultobj = NULL;
26205 wxWindow *arg1 = (wxWindow *) 0 ;
26206 wxString *arg2 = 0 ;
26207 bool temp2 = false ;
26208 PyObject * obj0 = 0 ;
26209 PyObject * obj1 = 0 ;
26210 char *kwnames[] = {
26211 (char *) "self",(char *) "name", NULL
26212 };
26213
26214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
26215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26216 if (SWIG_arg_fail(1)) SWIG_fail;
26217 {
26218 arg2 = wxString_in_helper(obj1);
26219 if (arg2 == NULL) SWIG_fail;
26220 temp2 = true;
26221 }
26222 {
26223 PyThreadState* __tstate = wxPyBeginAllowThreads();
26224 (arg1)->SetName((wxString const &)*arg2);
26225
26226 wxPyEndAllowThreads(__tstate);
26227 if (PyErr_Occurred()) SWIG_fail;
26228 }
26229 Py_INCREF(Py_None); resultobj = Py_None;
26230 {
26231 if (temp2)
26232 delete arg2;
26233 }
26234 return resultobj;
26235 fail:
26236 {
26237 if (temp2)
26238 delete arg2;
26239 }
26240 return NULL;
26241 }
26242
26243
26244 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
26245 PyObject *resultobj = NULL;
26246 wxWindow *arg1 = (wxWindow *) 0 ;
26247 wxString result;
26248 PyObject * obj0 = 0 ;
26249 char *kwnames[] = {
26250 (char *) "self", NULL
26251 };
26252
26253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
26254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26255 if (SWIG_arg_fail(1)) SWIG_fail;
26256 {
26257 PyThreadState* __tstate = wxPyBeginAllowThreads();
26258 result = ((wxWindow const *)arg1)->GetName();
26259
26260 wxPyEndAllowThreads(__tstate);
26261 if (PyErr_Occurred()) SWIG_fail;
26262 }
26263 {
26264 #if wxUSE_UNICODE
26265 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26266 #else
26267 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26268 #endif
26269 }
26270 return resultobj;
26271 fail:
26272 return NULL;
26273 }
26274
26275
26276 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26277 PyObject *resultobj = NULL;
26278 wxWindow *arg1 = (wxWindow *) 0 ;
26279 wxWindowVariant arg2 ;
26280 PyObject * obj0 = 0 ;
26281 PyObject * obj1 = 0 ;
26282 char *kwnames[] = {
26283 (char *) "self",(char *) "variant", NULL
26284 };
26285
26286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
26287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26288 if (SWIG_arg_fail(1)) SWIG_fail;
26289 {
26290 arg2 = static_cast<wxWindowVariant >(SWIG_As_int(obj1));
26291 if (SWIG_arg_fail(2)) SWIG_fail;
26292 }
26293 {
26294 PyThreadState* __tstate = wxPyBeginAllowThreads();
26295 (arg1)->SetWindowVariant(arg2);
26296
26297 wxPyEndAllowThreads(__tstate);
26298 if (PyErr_Occurred()) SWIG_fail;
26299 }
26300 Py_INCREF(Py_None); resultobj = Py_None;
26301 return resultobj;
26302 fail:
26303 return NULL;
26304 }
26305
26306
26307 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26308 PyObject *resultobj = NULL;
26309 wxWindow *arg1 = (wxWindow *) 0 ;
26310 wxWindowVariant result;
26311 PyObject * obj0 = 0 ;
26312 char *kwnames[] = {
26313 (char *) "self", NULL
26314 };
26315
26316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
26317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26318 if (SWIG_arg_fail(1)) SWIG_fail;
26319 {
26320 PyThreadState* __tstate = wxPyBeginAllowThreads();
26321 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
26322
26323 wxPyEndAllowThreads(__tstate);
26324 if (PyErr_Occurred()) SWIG_fail;
26325 }
26326 resultobj = SWIG_From_int((result));
26327 return resultobj;
26328 fail:
26329 return NULL;
26330 }
26331
26332
26333 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26334 PyObject *resultobj = NULL;
26335 wxWindow *arg1 = (wxWindow *) 0 ;
26336 int arg2 ;
26337 PyObject * obj0 = 0 ;
26338 PyObject * obj1 = 0 ;
26339 char *kwnames[] = {
26340 (char *) "self",(char *) "winid", NULL
26341 };
26342
26343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
26344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26345 if (SWIG_arg_fail(1)) SWIG_fail;
26346 {
26347 arg2 = static_cast<int >(SWIG_As_int(obj1));
26348 if (SWIG_arg_fail(2)) SWIG_fail;
26349 }
26350 {
26351 PyThreadState* __tstate = wxPyBeginAllowThreads();
26352 (arg1)->SetId(arg2);
26353
26354 wxPyEndAllowThreads(__tstate);
26355 if (PyErr_Occurred()) SWIG_fail;
26356 }
26357 Py_INCREF(Py_None); resultobj = Py_None;
26358 return resultobj;
26359 fail:
26360 return NULL;
26361 }
26362
26363
26364 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26365 PyObject *resultobj = NULL;
26366 wxWindow *arg1 = (wxWindow *) 0 ;
26367 int result;
26368 PyObject * obj0 = 0 ;
26369 char *kwnames[] = {
26370 (char *) "self", NULL
26371 };
26372
26373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
26374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26375 if (SWIG_arg_fail(1)) SWIG_fail;
26376 {
26377 PyThreadState* __tstate = wxPyBeginAllowThreads();
26378 result = (int)((wxWindow const *)arg1)->GetId();
26379
26380 wxPyEndAllowThreads(__tstate);
26381 if (PyErr_Occurred()) SWIG_fail;
26382 }
26383 {
26384 resultobj = SWIG_From_int(static_cast<int >(result));
26385 }
26386 return resultobj;
26387 fail:
26388 return NULL;
26389 }
26390
26391
26392 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26393 PyObject *resultobj = NULL;
26394 int result;
26395 char *kwnames[] = {
26396 NULL
26397 };
26398
26399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
26400 {
26401 PyThreadState* __tstate = wxPyBeginAllowThreads();
26402 result = (int)wxWindow::NewControlId();
26403
26404 wxPyEndAllowThreads(__tstate);
26405 if (PyErr_Occurred()) SWIG_fail;
26406 }
26407 {
26408 resultobj = SWIG_From_int(static_cast<int >(result));
26409 }
26410 return resultobj;
26411 fail:
26412 return NULL;
26413 }
26414
26415
26416 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26417 PyObject *resultobj = NULL;
26418 int arg1 ;
26419 int result;
26420 PyObject * obj0 = 0 ;
26421 char *kwnames[] = {
26422 (char *) "winid", NULL
26423 };
26424
26425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
26426 {
26427 arg1 = static_cast<int >(SWIG_As_int(obj0));
26428 if (SWIG_arg_fail(1)) SWIG_fail;
26429 }
26430 {
26431 PyThreadState* __tstate = wxPyBeginAllowThreads();
26432 result = (int)wxWindow::NextControlId(arg1);
26433
26434 wxPyEndAllowThreads(__tstate);
26435 if (PyErr_Occurred()) SWIG_fail;
26436 }
26437 {
26438 resultobj = SWIG_From_int(static_cast<int >(result));
26439 }
26440 return resultobj;
26441 fail:
26442 return NULL;
26443 }
26444
26445
26446 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26447 PyObject *resultobj = NULL;
26448 int arg1 ;
26449 int result;
26450 PyObject * obj0 = 0 ;
26451 char *kwnames[] = {
26452 (char *) "winid", NULL
26453 };
26454
26455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
26456 {
26457 arg1 = static_cast<int >(SWIG_As_int(obj0));
26458 if (SWIG_arg_fail(1)) SWIG_fail;
26459 }
26460 {
26461 PyThreadState* __tstate = wxPyBeginAllowThreads();
26462 result = (int)wxWindow::PrevControlId(arg1);
26463
26464 wxPyEndAllowThreads(__tstate);
26465 if (PyErr_Occurred()) SWIG_fail;
26466 }
26467 {
26468 resultobj = SWIG_From_int(static_cast<int >(result));
26469 }
26470 return resultobj;
26471 fail:
26472 return NULL;
26473 }
26474
26475
26476 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26477 PyObject *resultobj = NULL;
26478 wxWindow *arg1 = (wxWindow *) 0 ;
26479 wxSize *arg2 = 0 ;
26480 wxSize temp2 ;
26481 PyObject * obj0 = 0 ;
26482 PyObject * obj1 = 0 ;
26483 char *kwnames[] = {
26484 (char *) "self",(char *) "size", NULL
26485 };
26486
26487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
26488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26489 if (SWIG_arg_fail(1)) SWIG_fail;
26490 {
26491 arg2 = &temp2;
26492 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26493 }
26494 {
26495 PyThreadState* __tstate = wxPyBeginAllowThreads();
26496 (arg1)->SetSize((wxSize const &)*arg2);
26497
26498 wxPyEndAllowThreads(__tstate);
26499 if (PyErr_Occurred()) SWIG_fail;
26500 }
26501 Py_INCREF(Py_None); resultobj = Py_None;
26502 return resultobj;
26503 fail:
26504 return NULL;
26505 }
26506
26507
26508 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
26509 PyObject *resultobj = NULL;
26510 wxWindow *arg1 = (wxWindow *) 0 ;
26511 int arg2 ;
26512 int arg3 ;
26513 int arg4 ;
26514 int arg5 ;
26515 int arg6 = (int) wxSIZE_AUTO ;
26516 PyObject * obj0 = 0 ;
26517 PyObject * obj1 = 0 ;
26518 PyObject * obj2 = 0 ;
26519 PyObject * obj3 = 0 ;
26520 PyObject * obj4 = 0 ;
26521 PyObject * obj5 = 0 ;
26522 char *kwnames[] = {
26523 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
26524 };
26525
26526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
26527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26528 if (SWIG_arg_fail(1)) SWIG_fail;
26529 {
26530 arg2 = static_cast<int >(SWIG_As_int(obj1));
26531 if (SWIG_arg_fail(2)) SWIG_fail;
26532 }
26533 {
26534 arg3 = static_cast<int >(SWIG_As_int(obj2));
26535 if (SWIG_arg_fail(3)) SWIG_fail;
26536 }
26537 {
26538 arg4 = static_cast<int >(SWIG_As_int(obj3));
26539 if (SWIG_arg_fail(4)) SWIG_fail;
26540 }
26541 {
26542 arg5 = static_cast<int >(SWIG_As_int(obj4));
26543 if (SWIG_arg_fail(5)) SWIG_fail;
26544 }
26545 if (obj5) {
26546 {
26547 arg6 = static_cast<int >(SWIG_As_int(obj5));
26548 if (SWIG_arg_fail(6)) SWIG_fail;
26549 }
26550 }
26551 {
26552 PyThreadState* __tstate = wxPyBeginAllowThreads();
26553 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
26554
26555 wxPyEndAllowThreads(__tstate);
26556 if (PyErr_Occurred()) SWIG_fail;
26557 }
26558 Py_INCREF(Py_None); resultobj = Py_None;
26559 return resultobj;
26560 fail:
26561 return NULL;
26562 }
26563
26564
26565 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26566 PyObject *resultobj = NULL;
26567 wxWindow *arg1 = (wxWindow *) 0 ;
26568 wxRect *arg2 = 0 ;
26569 int arg3 = (int) wxSIZE_AUTO ;
26570 wxRect temp2 ;
26571 PyObject * obj0 = 0 ;
26572 PyObject * obj1 = 0 ;
26573 PyObject * obj2 = 0 ;
26574 char *kwnames[] = {
26575 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
26576 };
26577
26578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
26579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26580 if (SWIG_arg_fail(1)) SWIG_fail;
26581 {
26582 arg2 = &temp2;
26583 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26584 }
26585 if (obj2) {
26586 {
26587 arg3 = static_cast<int >(SWIG_As_int(obj2));
26588 if (SWIG_arg_fail(3)) SWIG_fail;
26589 }
26590 }
26591 {
26592 PyThreadState* __tstate = wxPyBeginAllowThreads();
26593 (arg1)->SetSize((wxRect const &)*arg2,arg3);
26594
26595 wxPyEndAllowThreads(__tstate);
26596 if (PyErr_Occurred()) SWIG_fail;
26597 }
26598 Py_INCREF(Py_None); resultobj = Py_None;
26599 return resultobj;
26600 fail:
26601 return NULL;
26602 }
26603
26604
26605 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26606 PyObject *resultobj = NULL;
26607 wxWindow *arg1 = (wxWindow *) 0 ;
26608 int arg2 ;
26609 int arg3 ;
26610 PyObject * obj0 = 0 ;
26611 PyObject * obj1 = 0 ;
26612 PyObject * obj2 = 0 ;
26613 char *kwnames[] = {
26614 (char *) "self",(char *) "width",(char *) "height", NULL
26615 };
26616
26617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26619 if (SWIG_arg_fail(1)) SWIG_fail;
26620 {
26621 arg2 = static_cast<int >(SWIG_As_int(obj1));
26622 if (SWIG_arg_fail(2)) SWIG_fail;
26623 }
26624 {
26625 arg3 = static_cast<int >(SWIG_As_int(obj2));
26626 if (SWIG_arg_fail(3)) SWIG_fail;
26627 }
26628 {
26629 PyThreadState* __tstate = wxPyBeginAllowThreads();
26630 (arg1)->SetSize(arg2,arg3);
26631
26632 wxPyEndAllowThreads(__tstate);
26633 if (PyErr_Occurred()) SWIG_fail;
26634 }
26635 Py_INCREF(Py_None); resultobj = Py_None;
26636 return resultobj;
26637 fail:
26638 return NULL;
26639 }
26640
26641
26642 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
26643 PyObject *resultobj = NULL;
26644 wxWindow *arg1 = (wxWindow *) 0 ;
26645 wxPoint *arg2 = 0 ;
26646 int arg3 = (int) wxSIZE_USE_EXISTING ;
26647 wxPoint temp2 ;
26648 PyObject * obj0 = 0 ;
26649 PyObject * obj1 = 0 ;
26650 PyObject * obj2 = 0 ;
26651 char *kwnames[] = {
26652 (char *) "self",(char *) "pt",(char *) "flags", NULL
26653 };
26654
26655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
26656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26657 if (SWIG_arg_fail(1)) SWIG_fail;
26658 {
26659 arg2 = &temp2;
26660 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26661 }
26662 if (obj2) {
26663 {
26664 arg3 = static_cast<int >(SWIG_As_int(obj2));
26665 if (SWIG_arg_fail(3)) SWIG_fail;
26666 }
26667 }
26668 {
26669 PyThreadState* __tstate = wxPyBeginAllowThreads();
26670 (arg1)->Move((wxPoint const &)*arg2,arg3);
26671
26672 wxPyEndAllowThreads(__tstate);
26673 if (PyErr_Occurred()) SWIG_fail;
26674 }
26675 Py_INCREF(Py_None); resultobj = Py_None;
26676 return resultobj;
26677 fail:
26678 return NULL;
26679 }
26680
26681
26682 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
26683 PyObject *resultobj = NULL;
26684 wxWindow *arg1 = (wxWindow *) 0 ;
26685 int arg2 ;
26686 int arg3 ;
26687 int arg4 = (int) wxSIZE_USE_EXISTING ;
26688 PyObject * obj0 = 0 ;
26689 PyObject * obj1 = 0 ;
26690 PyObject * obj2 = 0 ;
26691 PyObject * obj3 = 0 ;
26692 char *kwnames[] = {
26693 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
26694 };
26695
26696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26698 if (SWIG_arg_fail(1)) SWIG_fail;
26699 {
26700 arg2 = static_cast<int >(SWIG_As_int(obj1));
26701 if (SWIG_arg_fail(2)) SWIG_fail;
26702 }
26703 {
26704 arg3 = static_cast<int >(SWIG_As_int(obj2));
26705 if (SWIG_arg_fail(3)) SWIG_fail;
26706 }
26707 if (obj3) {
26708 {
26709 arg4 = static_cast<int >(SWIG_As_int(obj3));
26710 if (SWIG_arg_fail(4)) SWIG_fail;
26711 }
26712 }
26713 {
26714 PyThreadState* __tstate = wxPyBeginAllowThreads();
26715 (arg1)->Move(arg2,arg3,arg4);
26716
26717 wxPyEndAllowThreads(__tstate);
26718 if (PyErr_Occurred()) SWIG_fail;
26719 }
26720 Py_INCREF(Py_None); resultobj = Py_None;
26721 return resultobj;
26722 fail:
26723 return NULL;
26724 }
26725
26726
26727 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26728 PyObject *resultobj = NULL;
26729 wxWindow *arg1 = (wxWindow *) 0 ;
26730 wxSize const &arg2_defvalue = wxDefaultSize ;
26731 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
26732 wxSize temp2 ;
26733 PyObject * obj0 = 0 ;
26734 PyObject * obj1 = 0 ;
26735 char *kwnames[] = {
26736 (char *) "self",(char *) "size", NULL
26737 };
26738
26739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
26740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26741 if (SWIG_arg_fail(1)) SWIG_fail;
26742 if (obj1) {
26743 {
26744 arg2 = &temp2;
26745 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26746 }
26747 }
26748 {
26749 PyThreadState* __tstate = wxPyBeginAllowThreads();
26750 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
26751
26752 wxPyEndAllowThreads(__tstate);
26753 if (PyErr_Occurred()) SWIG_fail;
26754 }
26755 Py_INCREF(Py_None); resultobj = Py_None;
26756 return resultobj;
26757 fail:
26758 return NULL;
26759 }
26760
26761
26762 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26763 PyObject *resultobj = NULL;
26764 wxWindow *arg1 = (wxWindow *) 0 ;
26765 PyObject * obj0 = 0 ;
26766 char *kwnames[] = {
26767 (char *) "self", NULL
26768 };
26769
26770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26772 if (SWIG_arg_fail(1)) SWIG_fail;
26773 {
26774 PyThreadState* __tstate = wxPyBeginAllowThreads();
26775 (arg1)->Raise();
26776
26777 wxPyEndAllowThreads(__tstate);
26778 if (PyErr_Occurred()) SWIG_fail;
26779 }
26780 Py_INCREF(Py_None); resultobj = Py_None;
26781 return resultobj;
26782 fail:
26783 return NULL;
26784 }
26785
26786
26787 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26788 PyObject *resultobj = NULL;
26789 wxWindow *arg1 = (wxWindow *) 0 ;
26790 PyObject * obj0 = 0 ;
26791 char *kwnames[] = {
26792 (char *) "self", NULL
26793 };
26794
26795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26797 if (SWIG_arg_fail(1)) SWIG_fail;
26798 {
26799 PyThreadState* __tstate = wxPyBeginAllowThreads();
26800 (arg1)->Lower();
26801
26802 wxPyEndAllowThreads(__tstate);
26803 if (PyErr_Occurred()) SWIG_fail;
26804 }
26805 Py_INCREF(Py_None); resultobj = Py_None;
26806 return resultobj;
26807 fail:
26808 return NULL;
26809 }
26810
26811
26812 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26813 PyObject *resultobj = NULL;
26814 wxWindow *arg1 = (wxWindow *) 0 ;
26815 wxSize *arg2 = 0 ;
26816 wxSize temp2 ;
26817 PyObject * obj0 = 0 ;
26818 PyObject * obj1 = 0 ;
26819 char *kwnames[] = {
26820 (char *) "self",(char *) "size", NULL
26821 };
26822
26823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26825 if (SWIG_arg_fail(1)) SWIG_fail;
26826 {
26827 arg2 = &temp2;
26828 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26829 }
26830 {
26831 PyThreadState* __tstate = wxPyBeginAllowThreads();
26832 (arg1)->SetClientSize((wxSize const &)*arg2);
26833
26834 wxPyEndAllowThreads(__tstate);
26835 if (PyErr_Occurred()) SWIG_fail;
26836 }
26837 Py_INCREF(Py_None); resultobj = Py_None;
26838 return resultobj;
26839 fail:
26840 return NULL;
26841 }
26842
26843
26844 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26845 PyObject *resultobj = NULL;
26846 wxWindow *arg1 = (wxWindow *) 0 ;
26847 int arg2 ;
26848 int arg3 ;
26849 PyObject * obj0 = 0 ;
26850 PyObject * obj1 = 0 ;
26851 PyObject * obj2 = 0 ;
26852 char *kwnames[] = {
26853 (char *) "self",(char *) "width",(char *) "height", NULL
26854 };
26855
26856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26858 if (SWIG_arg_fail(1)) SWIG_fail;
26859 {
26860 arg2 = static_cast<int >(SWIG_As_int(obj1));
26861 if (SWIG_arg_fail(2)) SWIG_fail;
26862 }
26863 {
26864 arg3 = static_cast<int >(SWIG_As_int(obj2));
26865 if (SWIG_arg_fail(3)) SWIG_fail;
26866 }
26867 {
26868 PyThreadState* __tstate = wxPyBeginAllowThreads();
26869 (arg1)->SetClientSize(arg2,arg3);
26870
26871 wxPyEndAllowThreads(__tstate);
26872 if (PyErr_Occurred()) SWIG_fail;
26873 }
26874 Py_INCREF(Py_None); resultobj = Py_None;
26875 return resultobj;
26876 fail:
26877 return NULL;
26878 }
26879
26880
26881 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26882 PyObject *resultobj = NULL;
26883 wxWindow *arg1 = (wxWindow *) 0 ;
26884 wxRect *arg2 = 0 ;
26885 wxRect temp2 ;
26886 PyObject * obj0 = 0 ;
26887 PyObject * obj1 = 0 ;
26888 char *kwnames[] = {
26889 (char *) "self",(char *) "rect", NULL
26890 };
26891
26892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26894 if (SWIG_arg_fail(1)) SWIG_fail;
26895 {
26896 arg2 = &temp2;
26897 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26898 }
26899 {
26900 PyThreadState* __tstate = wxPyBeginAllowThreads();
26901 (arg1)->SetClientSize((wxRect const &)*arg2);
26902
26903 wxPyEndAllowThreads(__tstate);
26904 if (PyErr_Occurred()) SWIG_fail;
26905 }
26906 Py_INCREF(Py_None); resultobj = Py_None;
26907 return resultobj;
26908 fail:
26909 return NULL;
26910 }
26911
26912
26913 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26914 PyObject *resultobj = NULL;
26915 wxWindow *arg1 = (wxWindow *) 0 ;
26916 wxPoint result;
26917 PyObject * obj0 = 0 ;
26918 char *kwnames[] = {
26919 (char *) "self", NULL
26920 };
26921
26922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26924 if (SWIG_arg_fail(1)) SWIG_fail;
26925 {
26926 PyThreadState* __tstate = wxPyBeginAllowThreads();
26927 result = (arg1)->GetPosition();
26928
26929 wxPyEndAllowThreads(__tstate);
26930 if (PyErr_Occurred()) SWIG_fail;
26931 }
26932 {
26933 wxPoint * resultptr;
26934 resultptr = new wxPoint(static_cast<wxPoint & >(result));
26935 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26936 }
26937 return resultobj;
26938 fail:
26939 return NULL;
26940 }
26941
26942
26943 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26944 PyObject *resultobj = NULL;
26945 wxWindow *arg1 = (wxWindow *) 0 ;
26946 int *arg2 = (int *) 0 ;
26947 int *arg3 = (int *) 0 ;
26948 int temp2 ;
26949 int res2 = 0 ;
26950 int temp3 ;
26951 int res3 = 0 ;
26952 PyObject * obj0 = 0 ;
26953 char *kwnames[] = {
26954 (char *) "self", NULL
26955 };
26956
26957 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26958 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26961 if (SWIG_arg_fail(1)) SWIG_fail;
26962 {
26963 PyThreadState* __tstate = wxPyBeginAllowThreads();
26964 (arg1)->GetPosition(arg2,arg3);
26965
26966 wxPyEndAllowThreads(__tstate);
26967 if (PyErr_Occurred()) SWIG_fail;
26968 }
26969 Py_INCREF(Py_None); resultobj = Py_None;
26970 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26971 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26972 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26973 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26974 return resultobj;
26975 fail:
26976 return NULL;
26977 }
26978
26979
26980 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26981 PyObject *resultobj = NULL;
26982 wxWindow *arg1 = (wxWindow *) 0 ;
26983 wxSize result;
26984 PyObject * obj0 = 0 ;
26985 char *kwnames[] = {
26986 (char *) "self", NULL
26987 };
26988
26989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26991 if (SWIG_arg_fail(1)) SWIG_fail;
26992 {
26993 PyThreadState* __tstate = wxPyBeginAllowThreads();
26994 result = ((wxWindow const *)arg1)->GetSize();
26995
26996 wxPyEndAllowThreads(__tstate);
26997 if (PyErr_Occurred()) SWIG_fail;
26998 }
26999 {
27000 wxSize * resultptr;
27001 resultptr = new wxSize(static_cast<wxSize & >(result));
27002 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27003 }
27004 return resultobj;
27005 fail:
27006 return NULL;
27007 }
27008
27009
27010 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27011 PyObject *resultobj = NULL;
27012 wxWindow *arg1 = (wxWindow *) 0 ;
27013 int *arg2 = (int *) 0 ;
27014 int *arg3 = (int *) 0 ;
27015 int temp2 ;
27016 int res2 = 0 ;
27017 int temp3 ;
27018 int res3 = 0 ;
27019 PyObject * obj0 = 0 ;
27020 char *kwnames[] = {
27021 (char *) "self", NULL
27022 };
27023
27024 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27025 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
27027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27028 if (SWIG_arg_fail(1)) SWIG_fail;
27029 {
27030 PyThreadState* __tstate = wxPyBeginAllowThreads();
27031 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
27032
27033 wxPyEndAllowThreads(__tstate);
27034 if (PyErr_Occurred()) SWIG_fail;
27035 }
27036 Py_INCREF(Py_None); resultobj = Py_None;
27037 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27038 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27039 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27040 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27041 return resultobj;
27042 fail:
27043 return NULL;
27044 }
27045
27046
27047 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
27048 PyObject *resultobj = NULL;
27049 wxWindow *arg1 = (wxWindow *) 0 ;
27050 wxRect result;
27051 PyObject * obj0 = 0 ;
27052 char *kwnames[] = {
27053 (char *) "self", NULL
27054 };
27055
27056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
27057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27058 if (SWIG_arg_fail(1)) SWIG_fail;
27059 {
27060 PyThreadState* __tstate = wxPyBeginAllowThreads();
27061 result = ((wxWindow const *)arg1)->GetRect();
27062
27063 wxPyEndAllowThreads(__tstate);
27064 if (PyErr_Occurred()) SWIG_fail;
27065 }
27066 {
27067 wxRect * resultptr;
27068 resultptr = new wxRect(static_cast<wxRect & >(result));
27069 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
27070 }
27071 return resultobj;
27072 fail:
27073 return NULL;
27074 }
27075
27076
27077 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
27078 PyObject *resultobj = NULL;
27079 wxWindow *arg1 = (wxWindow *) 0 ;
27080 wxSize result;
27081 PyObject * obj0 = 0 ;
27082 char *kwnames[] = {
27083 (char *) "self", NULL
27084 };
27085
27086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
27087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27088 if (SWIG_arg_fail(1)) SWIG_fail;
27089 {
27090 PyThreadState* __tstate = wxPyBeginAllowThreads();
27091 result = ((wxWindow const *)arg1)->GetClientSize();
27092
27093 wxPyEndAllowThreads(__tstate);
27094 if (PyErr_Occurred()) SWIG_fail;
27095 }
27096 {
27097 wxSize * resultptr;
27098 resultptr = new wxSize(static_cast<wxSize & >(result));
27099 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27100 }
27101 return resultobj;
27102 fail:
27103 return NULL;
27104 }
27105
27106
27107 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27108 PyObject *resultobj = NULL;
27109 wxWindow *arg1 = (wxWindow *) 0 ;
27110 int *arg2 = (int *) 0 ;
27111 int *arg3 = (int *) 0 ;
27112 int temp2 ;
27113 int res2 = 0 ;
27114 int temp3 ;
27115 int res3 = 0 ;
27116 PyObject * obj0 = 0 ;
27117 char *kwnames[] = {
27118 (char *) "self", NULL
27119 };
27120
27121 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27122 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
27124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27125 if (SWIG_arg_fail(1)) SWIG_fail;
27126 {
27127 PyThreadState* __tstate = wxPyBeginAllowThreads();
27128 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
27129
27130 wxPyEndAllowThreads(__tstate);
27131 if (PyErr_Occurred()) SWIG_fail;
27132 }
27133 Py_INCREF(Py_None); resultobj = Py_None;
27134 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27135 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27136 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27137 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27138 return resultobj;
27139 fail:
27140 return NULL;
27141 }
27142
27143
27144 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
27145 PyObject *resultobj = NULL;
27146 wxWindow *arg1 = (wxWindow *) 0 ;
27147 wxPoint result;
27148 PyObject * obj0 = 0 ;
27149 char *kwnames[] = {
27150 (char *) "self", NULL
27151 };
27152
27153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
27154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27155 if (SWIG_arg_fail(1)) SWIG_fail;
27156 {
27157 PyThreadState* __tstate = wxPyBeginAllowThreads();
27158 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
27159
27160 wxPyEndAllowThreads(__tstate);
27161 if (PyErr_Occurred()) SWIG_fail;
27162 }
27163 {
27164 wxPoint * resultptr;
27165 resultptr = new wxPoint(static_cast<wxPoint & >(result));
27166 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
27167 }
27168 return resultobj;
27169 fail:
27170 return NULL;
27171 }
27172
27173
27174 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
27175 PyObject *resultobj = NULL;
27176 wxWindow *arg1 = (wxWindow *) 0 ;
27177 wxRect result;
27178 PyObject * obj0 = 0 ;
27179 char *kwnames[] = {
27180 (char *) "self", NULL
27181 };
27182
27183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
27184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27185 if (SWIG_arg_fail(1)) SWIG_fail;
27186 {
27187 PyThreadState* __tstate = wxPyBeginAllowThreads();
27188 result = ((wxWindow const *)arg1)->GetClientRect();
27189
27190 wxPyEndAllowThreads(__tstate);
27191 if (PyErr_Occurred()) SWIG_fail;
27192 }
27193 {
27194 wxRect * resultptr;
27195 resultptr = new wxRect(static_cast<wxRect & >(result));
27196 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
27197 }
27198 return resultobj;
27199 fail:
27200 return NULL;
27201 }
27202
27203
27204 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27205 PyObject *resultobj = NULL;
27206 wxWindow *arg1 = (wxWindow *) 0 ;
27207 wxSize result;
27208 PyObject * obj0 = 0 ;
27209 char *kwnames[] = {
27210 (char *) "self", NULL
27211 };
27212
27213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
27214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27215 if (SWIG_arg_fail(1)) SWIG_fail;
27216 {
27217 PyThreadState* __tstate = wxPyBeginAllowThreads();
27218 result = ((wxWindow const *)arg1)->GetBestSize();
27219
27220 wxPyEndAllowThreads(__tstate);
27221 if (PyErr_Occurred()) SWIG_fail;
27222 }
27223 {
27224 wxSize * resultptr;
27225 resultptr = new wxSize(static_cast<wxSize & >(result));
27226 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27227 }
27228 return resultobj;
27229 fail:
27230 return NULL;
27231 }
27232
27233
27234 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27235 PyObject *resultobj = NULL;
27236 wxWindow *arg1 = (wxWindow *) 0 ;
27237 int *arg2 = (int *) 0 ;
27238 int *arg3 = (int *) 0 ;
27239 int temp2 ;
27240 int res2 = 0 ;
27241 int temp3 ;
27242 int res3 = 0 ;
27243 PyObject * obj0 = 0 ;
27244 char *kwnames[] = {
27245 (char *) "self", NULL
27246 };
27247
27248 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27249 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
27251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27252 if (SWIG_arg_fail(1)) SWIG_fail;
27253 {
27254 PyThreadState* __tstate = wxPyBeginAllowThreads();
27255 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
27256
27257 wxPyEndAllowThreads(__tstate);
27258 if (PyErr_Occurred()) SWIG_fail;
27259 }
27260 Py_INCREF(Py_None); resultobj = Py_None;
27261 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27262 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27263 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27264 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27265 return resultobj;
27266 fail:
27267 return NULL;
27268 }
27269
27270
27271 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27272 PyObject *resultobj = NULL;
27273 wxWindow *arg1 = (wxWindow *) 0 ;
27274 PyObject * obj0 = 0 ;
27275 char *kwnames[] = {
27276 (char *) "self", NULL
27277 };
27278
27279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
27280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27281 if (SWIG_arg_fail(1)) SWIG_fail;
27282 {
27283 PyThreadState* __tstate = wxPyBeginAllowThreads();
27284 (arg1)->InvalidateBestSize();
27285
27286 wxPyEndAllowThreads(__tstate);
27287 if (PyErr_Occurred()) SWIG_fail;
27288 }
27289 Py_INCREF(Py_None); resultobj = Py_None;
27290 return resultobj;
27291 fail:
27292 return NULL;
27293 }
27294
27295
27296 static PyObject *_wrap_Window_CacheBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27297 PyObject *resultobj = NULL;
27298 wxWindow *arg1 = (wxWindow *) 0 ;
27299 wxSize *arg2 = 0 ;
27300 wxSize temp2 ;
27301 PyObject * obj0 = 0 ;
27302 PyObject * obj1 = 0 ;
27303 char *kwnames[] = {
27304 (char *) "self",(char *) "size", NULL
27305 };
27306
27307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) goto fail;
27308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27309 if (SWIG_arg_fail(1)) SWIG_fail;
27310 {
27311 arg2 = &temp2;
27312 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27313 }
27314 {
27315 PyThreadState* __tstate = wxPyBeginAllowThreads();
27316 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
27317
27318 wxPyEndAllowThreads(__tstate);
27319 if (PyErr_Occurred()) SWIG_fail;
27320 }
27321 Py_INCREF(Py_None); resultobj = Py_None;
27322 return resultobj;
27323 fail:
27324 return NULL;
27325 }
27326
27327
27328 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
27329 PyObject *resultobj = NULL;
27330 wxWindow *arg1 = (wxWindow *) 0 ;
27331 wxSize result;
27332 PyObject * obj0 = 0 ;
27333 char *kwnames[] = {
27334 (char *) "self", NULL
27335 };
27336
27337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
27338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27339 if (SWIG_arg_fail(1)) SWIG_fail;
27340 {
27341 PyThreadState* __tstate = wxPyBeginAllowThreads();
27342 result = ((wxWindow const *)arg1)->GetBestFittingSize();
27343
27344 wxPyEndAllowThreads(__tstate);
27345 if (PyErr_Occurred()) SWIG_fail;
27346 }
27347 {
27348 wxSize * resultptr;
27349 resultptr = new wxSize(static_cast<wxSize & >(result));
27350 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27351 }
27352 return resultobj;
27353 fail:
27354 return NULL;
27355 }
27356
27357
27358 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27359 PyObject *resultobj = NULL;
27360 wxWindow *arg1 = (wxWindow *) 0 ;
27361 wxSize result;
27362 PyObject * obj0 = 0 ;
27363 char *kwnames[] = {
27364 (char *) "self", NULL
27365 };
27366
27367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
27368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27369 if (SWIG_arg_fail(1)) SWIG_fail;
27370 {
27371 PyThreadState* __tstate = wxPyBeginAllowThreads();
27372 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
27373
27374 wxPyEndAllowThreads(__tstate);
27375 if (PyErr_Occurred()) SWIG_fail;
27376 }
27377 {
27378 wxSize * resultptr;
27379 resultptr = new wxSize(static_cast<wxSize & >(result));
27380 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27381 }
27382 return resultobj;
27383 fail:
27384 return NULL;
27385 }
27386
27387
27388 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
27389 PyObject *resultobj = NULL;
27390 wxWindow *arg1 = (wxWindow *) 0 ;
27391 int arg2 = (int) wxBOTH ;
27392 PyObject * obj0 = 0 ;
27393 PyObject * obj1 = 0 ;
27394 char *kwnames[] = {
27395 (char *) "self",(char *) "direction", NULL
27396 };
27397
27398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
27399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27400 if (SWIG_arg_fail(1)) SWIG_fail;
27401 if (obj1) {
27402 {
27403 arg2 = static_cast<int >(SWIG_As_int(obj1));
27404 if (SWIG_arg_fail(2)) SWIG_fail;
27405 }
27406 }
27407 {
27408 PyThreadState* __tstate = wxPyBeginAllowThreads();
27409 (arg1)->Center(arg2);
27410
27411 wxPyEndAllowThreads(__tstate);
27412 if (PyErr_Occurred()) SWIG_fail;
27413 }
27414 Py_INCREF(Py_None); resultobj = Py_None;
27415 return resultobj;
27416 fail:
27417 return NULL;
27418 }
27419
27420
27421 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
27422 PyObject *resultobj = NULL;
27423 wxWindow *arg1 = (wxWindow *) 0 ;
27424 int arg2 = (int) wxBOTH ;
27425 PyObject * obj0 = 0 ;
27426 PyObject * obj1 = 0 ;
27427 char *kwnames[] = {
27428 (char *) "self",(char *) "dir", NULL
27429 };
27430
27431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
27432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27433 if (SWIG_arg_fail(1)) SWIG_fail;
27434 if (obj1) {
27435 {
27436 arg2 = static_cast<int >(SWIG_As_int(obj1));
27437 if (SWIG_arg_fail(2)) SWIG_fail;
27438 }
27439 }
27440 {
27441 PyThreadState* __tstate = wxPyBeginAllowThreads();
27442 (arg1)->CenterOnScreen(arg2);
27443
27444 wxPyEndAllowThreads(__tstate);
27445 if (PyErr_Occurred()) SWIG_fail;
27446 }
27447 Py_INCREF(Py_None); resultobj = Py_None;
27448 return resultobj;
27449 fail:
27450 return NULL;
27451 }
27452
27453
27454 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
27455 PyObject *resultobj = NULL;
27456 wxWindow *arg1 = (wxWindow *) 0 ;
27457 int arg2 = (int) wxBOTH ;
27458 PyObject * obj0 = 0 ;
27459 PyObject * obj1 = 0 ;
27460 char *kwnames[] = {
27461 (char *) "self",(char *) "dir", NULL
27462 };
27463
27464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
27465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27466 if (SWIG_arg_fail(1)) SWIG_fail;
27467 if (obj1) {
27468 {
27469 arg2 = static_cast<int >(SWIG_As_int(obj1));
27470 if (SWIG_arg_fail(2)) SWIG_fail;
27471 }
27472 }
27473 {
27474 PyThreadState* __tstate = wxPyBeginAllowThreads();
27475 (arg1)->CenterOnParent(arg2);
27476
27477 wxPyEndAllowThreads(__tstate);
27478 if (PyErr_Occurred()) SWIG_fail;
27479 }
27480 Py_INCREF(Py_None); resultobj = Py_None;
27481 return resultobj;
27482 fail:
27483 return NULL;
27484 }
27485
27486
27487 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
27488 PyObject *resultobj = NULL;
27489 wxWindow *arg1 = (wxWindow *) 0 ;
27490 PyObject * obj0 = 0 ;
27491 char *kwnames[] = {
27492 (char *) "self", NULL
27493 };
27494
27495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
27496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27497 if (SWIG_arg_fail(1)) SWIG_fail;
27498 {
27499 PyThreadState* __tstate = wxPyBeginAllowThreads();
27500 (arg1)->Fit();
27501
27502 wxPyEndAllowThreads(__tstate);
27503 if (PyErr_Occurred()) SWIG_fail;
27504 }
27505 Py_INCREF(Py_None); resultobj = Py_None;
27506 return resultobj;
27507 fail:
27508 return NULL;
27509 }
27510
27511
27512 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
27513 PyObject *resultobj = NULL;
27514 wxWindow *arg1 = (wxWindow *) 0 ;
27515 PyObject * obj0 = 0 ;
27516 char *kwnames[] = {
27517 (char *) "self", NULL
27518 };
27519
27520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
27521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27522 if (SWIG_arg_fail(1)) SWIG_fail;
27523 {
27524 PyThreadState* __tstate = wxPyBeginAllowThreads();
27525 (arg1)->FitInside();
27526
27527 wxPyEndAllowThreads(__tstate);
27528 if (PyErr_Occurred()) SWIG_fail;
27529 }
27530 Py_INCREF(Py_None); resultobj = Py_None;
27531 return resultobj;
27532 fail:
27533 return NULL;
27534 }
27535
27536
27537 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27538 PyObject *resultobj = NULL;
27539 wxWindow *arg1 = (wxWindow *) 0 ;
27540 int arg2 ;
27541 int arg3 ;
27542 int arg4 = (int) -1 ;
27543 int arg5 = (int) -1 ;
27544 int arg6 = (int) -1 ;
27545 int arg7 = (int) -1 ;
27546 PyObject * obj0 = 0 ;
27547 PyObject * obj1 = 0 ;
27548 PyObject * obj2 = 0 ;
27549 PyObject * obj3 = 0 ;
27550 PyObject * obj4 = 0 ;
27551 PyObject * obj5 = 0 ;
27552 PyObject * obj6 = 0 ;
27553 char *kwnames[] = {
27554 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
27555 };
27556
27557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27559 if (SWIG_arg_fail(1)) SWIG_fail;
27560 {
27561 arg2 = static_cast<int >(SWIG_As_int(obj1));
27562 if (SWIG_arg_fail(2)) SWIG_fail;
27563 }
27564 {
27565 arg3 = static_cast<int >(SWIG_As_int(obj2));
27566 if (SWIG_arg_fail(3)) SWIG_fail;
27567 }
27568 if (obj3) {
27569 {
27570 arg4 = static_cast<int >(SWIG_As_int(obj3));
27571 if (SWIG_arg_fail(4)) SWIG_fail;
27572 }
27573 }
27574 if (obj4) {
27575 {
27576 arg5 = static_cast<int >(SWIG_As_int(obj4));
27577 if (SWIG_arg_fail(5)) SWIG_fail;
27578 }
27579 }
27580 if (obj5) {
27581 {
27582 arg6 = static_cast<int >(SWIG_As_int(obj5));
27583 if (SWIG_arg_fail(6)) SWIG_fail;
27584 }
27585 }
27586 if (obj6) {
27587 {
27588 arg7 = static_cast<int >(SWIG_As_int(obj6));
27589 if (SWIG_arg_fail(7)) SWIG_fail;
27590 }
27591 }
27592 {
27593 PyThreadState* __tstate = wxPyBeginAllowThreads();
27594 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
27595
27596 wxPyEndAllowThreads(__tstate);
27597 if (PyErr_Occurred()) SWIG_fail;
27598 }
27599 Py_INCREF(Py_None); resultobj = Py_None;
27600 return resultobj;
27601 fail:
27602 return NULL;
27603 }
27604
27605
27606 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27607 PyObject *resultobj = NULL;
27608 wxWindow *arg1 = (wxWindow *) 0 ;
27609 wxSize *arg2 = 0 ;
27610 wxSize const &arg3_defvalue = wxDefaultSize ;
27611 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27612 wxSize const &arg4_defvalue = wxDefaultSize ;
27613 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
27614 wxSize temp2 ;
27615 wxSize temp3 ;
27616 wxSize temp4 ;
27617 PyObject * obj0 = 0 ;
27618 PyObject * obj1 = 0 ;
27619 PyObject * obj2 = 0 ;
27620 PyObject * obj3 = 0 ;
27621 char *kwnames[] = {
27622 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
27623 };
27624
27625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
27626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27627 if (SWIG_arg_fail(1)) SWIG_fail;
27628 {
27629 arg2 = &temp2;
27630 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27631 }
27632 if (obj2) {
27633 {
27634 arg3 = &temp3;
27635 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27636 }
27637 }
27638 if (obj3) {
27639 {
27640 arg4 = &temp4;
27641 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
27642 }
27643 }
27644 {
27645 PyThreadState* __tstate = wxPyBeginAllowThreads();
27646 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
27647
27648 wxPyEndAllowThreads(__tstate);
27649 if (PyErr_Occurred()) SWIG_fail;
27650 }
27651 Py_INCREF(Py_None); resultobj = Py_None;
27652 return resultobj;
27653 fail:
27654 return NULL;
27655 }
27656
27657
27658 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27659 PyObject *resultobj = NULL;
27660 wxWindow *arg1 = (wxWindow *) 0 ;
27661 int arg2 ;
27662 int arg3 ;
27663 int arg4 = (int) -1 ;
27664 int arg5 = (int) -1 ;
27665 PyObject * obj0 = 0 ;
27666 PyObject * obj1 = 0 ;
27667 PyObject * obj2 = 0 ;
27668 PyObject * obj3 = 0 ;
27669 PyObject * obj4 = 0 ;
27670 char *kwnames[] = {
27671 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
27672 };
27673
27674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
27675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27676 if (SWIG_arg_fail(1)) SWIG_fail;
27677 {
27678 arg2 = static_cast<int >(SWIG_As_int(obj1));
27679 if (SWIG_arg_fail(2)) SWIG_fail;
27680 }
27681 {
27682 arg3 = static_cast<int >(SWIG_As_int(obj2));
27683 if (SWIG_arg_fail(3)) SWIG_fail;
27684 }
27685 if (obj3) {
27686 {
27687 arg4 = static_cast<int >(SWIG_As_int(obj3));
27688 if (SWIG_arg_fail(4)) SWIG_fail;
27689 }
27690 }
27691 if (obj4) {
27692 {
27693 arg5 = static_cast<int >(SWIG_As_int(obj4));
27694 if (SWIG_arg_fail(5)) SWIG_fail;
27695 }
27696 }
27697 {
27698 PyThreadState* __tstate = wxPyBeginAllowThreads();
27699 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
27700
27701 wxPyEndAllowThreads(__tstate);
27702 if (PyErr_Occurred()) SWIG_fail;
27703 }
27704 Py_INCREF(Py_None); resultobj = Py_None;
27705 return resultobj;
27706 fail:
27707 return NULL;
27708 }
27709
27710
27711 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27712 PyObject *resultobj = NULL;
27713 wxWindow *arg1 = (wxWindow *) 0 ;
27714 wxSize *arg2 = 0 ;
27715 wxSize const &arg3_defvalue = wxDefaultSize ;
27716 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27717 wxSize temp2 ;
27718 wxSize temp3 ;
27719 PyObject * obj0 = 0 ;
27720 PyObject * obj1 = 0 ;
27721 PyObject * obj2 = 0 ;
27722 char *kwnames[] = {
27723 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
27724 };
27725
27726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
27727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27728 if (SWIG_arg_fail(1)) SWIG_fail;
27729 {
27730 arg2 = &temp2;
27731 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27732 }
27733 if (obj2) {
27734 {
27735 arg3 = &temp3;
27736 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27737 }
27738 }
27739 {
27740 PyThreadState* __tstate = wxPyBeginAllowThreads();
27741 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
27742
27743 wxPyEndAllowThreads(__tstate);
27744 if (PyErr_Occurred()) SWIG_fail;
27745 }
27746 Py_INCREF(Py_None); resultobj = Py_None;
27747 return resultobj;
27748 fail:
27749 return NULL;
27750 }
27751
27752
27753 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27754 PyObject *resultobj = NULL;
27755 wxWindow *arg1 = (wxWindow *) 0 ;
27756 wxSize result;
27757 PyObject * obj0 = 0 ;
27758 char *kwnames[] = {
27759 (char *) "self", NULL
27760 };
27761
27762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
27763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27764 if (SWIG_arg_fail(1)) SWIG_fail;
27765 {
27766 PyThreadState* __tstate = wxPyBeginAllowThreads();
27767 result = ((wxWindow const *)arg1)->GetMaxSize();
27768
27769 wxPyEndAllowThreads(__tstate);
27770 if (PyErr_Occurred()) SWIG_fail;
27771 }
27772 {
27773 wxSize * resultptr;
27774 resultptr = new wxSize(static_cast<wxSize & >(result));
27775 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27776 }
27777 return resultobj;
27778 fail:
27779 return NULL;
27780 }
27781
27782
27783 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27784 PyObject *resultobj = NULL;
27785 wxWindow *arg1 = (wxWindow *) 0 ;
27786 wxSize result;
27787 PyObject * obj0 = 0 ;
27788 char *kwnames[] = {
27789 (char *) "self", NULL
27790 };
27791
27792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27794 if (SWIG_arg_fail(1)) SWIG_fail;
27795 {
27796 PyThreadState* __tstate = wxPyBeginAllowThreads();
27797 result = ((wxWindow const *)arg1)->GetMinSize();
27798
27799 wxPyEndAllowThreads(__tstate);
27800 if (PyErr_Occurred()) SWIG_fail;
27801 }
27802 {
27803 wxSize * resultptr;
27804 resultptr = new wxSize(static_cast<wxSize & >(result));
27805 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27806 }
27807 return resultobj;
27808 fail:
27809 return NULL;
27810 }
27811
27812
27813 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27814 PyObject *resultobj = NULL;
27815 wxWindow *arg1 = (wxWindow *) 0 ;
27816 wxSize *arg2 = 0 ;
27817 wxSize temp2 ;
27818 PyObject * obj0 = 0 ;
27819 PyObject * obj1 = 0 ;
27820 char *kwnames[] = {
27821 (char *) "self",(char *) "minSize", NULL
27822 };
27823
27824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27826 if (SWIG_arg_fail(1)) SWIG_fail;
27827 {
27828 arg2 = &temp2;
27829 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27830 }
27831 {
27832 PyThreadState* __tstate = wxPyBeginAllowThreads();
27833 (arg1)->SetMinSize((wxSize const &)*arg2);
27834
27835 wxPyEndAllowThreads(__tstate);
27836 if (PyErr_Occurred()) SWIG_fail;
27837 }
27838 Py_INCREF(Py_None); resultobj = Py_None;
27839 return resultobj;
27840 fail:
27841 return NULL;
27842 }
27843
27844
27845 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27846 PyObject *resultobj = NULL;
27847 wxWindow *arg1 = (wxWindow *) 0 ;
27848 wxSize *arg2 = 0 ;
27849 wxSize temp2 ;
27850 PyObject * obj0 = 0 ;
27851 PyObject * obj1 = 0 ;
27852 char *kwnames[] = {
27853 (char *) "self",(char *) "maxSize", NULL
27854 };
27855
27856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27858 if (SWIG_arg_fail(1)) SWIG_fail;
27859 {
27860 arg2 = &temp2;
27861 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27862 }
27863 {
27864 PyThreadState* __tstate = wxPyBeginAllowThreads();
27865 (arg1)->SetMaxSize((wxSize const &)*arg2);
27866
27867 wxPyEndAllowThreads(__tstate);
27868 if (PyErr_Occurred()) SWIG_fail;
27869 }
27870 Py_INCREF(Py_None); resultobj = Py_None;
27871 return resultobj;
27872 fail:
27873 return NULL;
27874 }
27875
27876
27877 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27878 PyObject *resultobj = NULL;
27879 wxWindow *arg1 = (wxWindow *) 0 ;
27880 int result;
27881 PyObject * obj0 = 0 ;
27882 char *kwnames[] = {
27883 (char *) "self", NULL
27884 };
27885
27886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27888 if (SWIG_arg_fail(1)) SWIG_fail;
27889 {
27890 PyThreadState* __tstate = wxPyBeginAllowThreads();
27891 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27892
27893 wxPyEndAllowThreads(__tstate);
27894 if (PyErr_Occurred()) SWIG_fail;
27895 }
27896 {
27897 resultobj = SWIG_From_int(static_cast<int >(result));
27898 }
27899 return resultobj;
27900 fail:
27901 return NULL;
27902 }
27903
27904
27905 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27906 PyObject *resultobj = NULL;
27907 wxWindow *arg1 = (wxWindow *) 0 ;
27908 int result;
27909 PyObject * obj0 = 0 ;
27910 char *kwnames[] = {
27911 (char *) "self", NULL
27912 };
27913
27914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27916 if (SWIG_arg_fail(1)) SWIG_fail;
27917 {
27918 PyThreadState* __tstate = wxPyBeginAllowThreads();
27919 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27920
27921 wxPyEndAllowThreads(__tstate);
27922 if (PyErr_Occurred()) SWIG_fail;
27923 }
27924 {
27925 resultobj = SWIG_From_int(static_cast<int >(result));
27926 }
27927 return resultobj;
27928 fail:
27929 return NULL;
27930 }
27931
27932
27933 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27934 PyObject *resultobj = NULL;
27935 wxWindow *arg1 = (wxWindow *) 0 ;
27936 int result;
27937 PyObject * obj0 = 0 ;
27938 char *kwnames[] = {
27939 (char *) "self", NULL
27940 };
27941
27942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27944 if (SWIG_arg_fail(1)) SWIG_fail;
27945 {
27946 PyThreadState* __tstate = wxPyBeginAllowThreads();
27947 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27948
27949 wxPyEndAllowThreads(__tstate);
27950 if (PyErr_Occurred()) SWIG_fail;
27951 }
27952 {
27953 resultobj = SWIG_From_int(static_cast<int >(result));
27954 }
27955 return resultobj;
27956 fail:
27957 return NULL;
27958 }
27959
27960
27961 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27962 PyObject *resultobj = NULL;
27963 wxWindow *arg1 = (wxWindow *) 0 ;
27964 int result;
27965 PyObject * obj0 = 0 ;
27966 char *kwnames[] = {
27967 (char *) "self", NULL
27968 };
27969
27970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27972 if (SWIG_arg_fail(1)) SWIG_fail;
27973 {
27974 PyThreadState* __tstate = wxPyBeginAllowThreads();
27975 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27976
27977 wxPyEndAllowThreads(__tstate);
27978 if (PyErr_Occurred()) SWIG_fail;
27979 }
27980 {
27981 resultobj = SWIG_From_int(static_cast<int >(result));
27982 }
27983 return resultobj;
27984 fail:
27985 return NULL;
27986 }
27987
27988
27989 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27990 PyObject *resultobj = NULL;
27991 wxWindow *arg1 = (wxWindow *) 0 ;
27992 wxSize *arg2 = 0 ;
27993 wxSize temp2 ;
27994 PyObject * obj0 = 0 ;
27995 PyObject * obj1 = 0 ;
27996 char *kwnames[] = {
27997 (char *) "self",(char *) "size", NULL
27998 };
27999
28000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
28001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28002 if (SWIG_arg_fail(1)) SWIG_fail;
28003 {
28004 arg2 = &temp2;
28005 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28006 }
28007 {
28008 PyThreadState* __tstate = wxPyBeginAllowThreads();
28009 (arg1)->SetVirtualSize((wxSize const &)*arg2);
28010
28011 wxPyEndAllowThreads(__tstate);
28012 if (PyErr_Occurred()) SWIG_fail;
28013 }
28014 Py_INCREF(Py_None); resultobj = Py_None;
28015 return resultobj;
28016 fail:
28017 return NULL;
28018 }
28019
28020
28021 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
28022 PyObject *resultobj = NULL;
28023 wxWindow *arg1 = (wxWindow *) 0 ;
28024 int arg2 ;
28025 int arg3 ;
28026 PyObject * obj0 = 0 ;
28027 PyObject * obj1 = 0 ;
28028 PyObject * obj2 = 0 ;
28029 char *kwnames[] = {
28030 (char *) "self",(char *) "w",(char *) "h", NULL
28031 };
28032
28033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
28034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28035 if (SWIG_arg_fail(1)) SWIG_fail;
28036 {
28037 arg2 = static_cast<int >(SWIG_As_int(obj1));
28038 if (SWIG_arg_fail(2)) SWIG_fail;
28039 }
28040 {
28041 arg3 = static_cast<int >(SWIG_As_int(obj2));
28042 if (SWIG_arg_fail(3)) SWIG_fail;
28043 }
28044 {
28045 PyThreadState* __tstate = wxPyBeginAllowThreads();
28046 (arg1)->SetVirtualSize(arg2,arg3);
28047
28048 wxPyEndAllowThreads(__tstate);
28049 if (PyErr_Occurred()) SWIG_fail;
28050 }
28051 Py_INCREF(Py_None); resultobj = Py_None;
28052 return resultobj;
28053 fail:
28054 return NULL;
28055 }
28056
28057
28058 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28059 PyObject *resultobj = NULL;
28060 wxWindow *arg1 = (wxWindow *) 0 ;
28061 wxSize result;
28062 PyObject * obj0 = 0 ;
28063 char *kwnames[] = {
28064 (char *) "self", NULL
28065 };
28066
28067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
28068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28069 if (SWIG_arg_fail(1)) SWIG_fail;
28070 {
28071 PyThreadState* __tstate = wxPyBeginAllowThreads();
28072 result = ((wxWindow const *)arg1)->GetVirtualSize();
28073
28074 wxPyEndAllowThreads(__tstate);
28075 if (PyErr_Occurred()) SWIG_fail;
28076 }
28077 {
28078 wxSize * resultptr;
28079 resultptr = new wxSize(static_cast<wxSize & >(result));
28080 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28081 }
28082 return resultobj;
28083 fail:
28084 return NULL;
28085 }
28086
28087
28088 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
28089 PyObject *resultobj = NULL;
28090 wxWindow *arg1 = (wxWindow *) 0 ;
28091 int *arg2 = (int *) 0 ;
28092 int *arg3 = (int *) 0 ;
28093 int temp2 ;
28094 int res2 = 0 ;
28095 int temp3 ;
28096 int res3 = 0 ;
28097 PyObject * obj0 = 0 ;
28098 char *kwnames[] = {
28099 (char *) "self", NULL
28100 };
28101
28102 arg2 = &temp2; res2 = SWIG_NEWOBJ;
28103 arg3 = &temp3; res3 = SWIG_NEWOBJ;
28104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
28105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28106 if (SWIG_arg_fail(1)) SWIG_fail;
28107 {
28108 PyThreadState* __tstate = wxPyBeginAllowThreads();
28109 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
28110
28111 wxPyEndAllowThreads(__tstate);
28112 if (PyErr_Occurred()) SWIG_fail;
28113 }
28114 Py_INCREF(Py_None); resultobj = Py_None;
28115 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
28116 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
28117 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
28118 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
28119 return resultobj;
28120 fail:
28121 return NULL;
28122 }
28123
28124
28125 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28126 PyObject *resultobj = NULL;
28127 wxWindow *arg1 = (wxWindow *) 0 ;
28128 wxSize result;
28129 PyObject * obj0 = 0 ;
28130 char *kwnames[] = {
28131 (char *) "self", NULL
28132 };
28133
28134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
28135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28136 if (SWIG_arg_fail(1)) SWIG_fail;
28137 {
28138 PyThreadState* __tstate = wxPyBeginAllowThreads();
28139 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
28140
28141 wxPyEndAllowThreads(__tstate);
28142 if (PyErr_Occurred()) SWIG_fail;
28143 }
28144 {
28145 wxSize * resultptr;
28146 resultptr = new wxSize(static_cast<wxSize & >(result));
28147 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28148 }
28149 return resultobj;
28150 fail:
28151 return NULL;
28152 }
28153
28154
28155 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
28156 PyObject *resultobj = NULL;
28157 wxWindow *arg1 = (wxWindow *) 0 ;
28158 bool arg2 = (bool) true ;
28159 bool result;
28160 PyObject * obj0 = 0 ;
28161 PyObject * obj1 = 0 ;
28162 char *kwnames[] = {
28163 (char *) "self",(char *) "show", NULL
28164 };
28165
28166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
28167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28168 if (SWIG_arg_fail(1)) SWIG_fail;
28169 if (obj1) {
28170 {
28171 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28172 if (SWIG_arg_fail(2)) SWIG_fail;
28173 }
28174 }
28175 {
28176 PyThreadState* __tstate = wxPyBeginAllowThreads();
28177 result = (bool)(arg1)->Show(arg2);
28178
28179 wxPyEndAllowThreads(__tstate);
28180 if (PyErr_Occurred()) SWIG_fail;
28181 }
28182 {
28183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28184 }
28185 return resultobj;
28186 fail:
28187 return NULL;
28188 }
28189
28190
28191 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
28192 PyObject *resultobj = NULL;
28193 wxWindow *arg1 = (wxWindow *) 0 ;
28194 bool result;
28195 PyObject * obj0 = 0 ;
28196 char *kwnames[] = {
28197 (char *) "self", NULL
28198 };
28199
28200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
28201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28202 if (SWIG_arg_fail(1)) SWIG_fail;
28203 {
28204 PyThreadState* __tstate = wxPyBeginAllowThreads();
28205 result = (bool)(arg1)->Hide();
28206
28207 wxPyEndAllowThreads(__tstate);
28208 if (PyErr_Occurred()) SWIG_fail;
28209 }
28210 {
28211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28212 }
28213 return resultobj;
28214 fail:
28215 return NULL;
28216 }
28217
28218
28219 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
28220 PyObject *resultobj = NULL;
28221 wxWindow *arg1 = (wxWindow *) 0 ;
28222 bool arg2 = (bool) true ;
28223 bool result;
28224 PyObject * obj0 = 0 ;
28225 PyObject * obj1 = 0 ;
28226 char *kwnames[] = {
28227 (char *) "self",(char *) "enable", NULL
28228 };
28229
28230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
28231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28232 if (SWIG_arg_fail(1)) SWIG_fail;
28233 if (obj1) {
28234 {
28235 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28236 if (SWIG_arg_fail(2)) SWIG_fail;
28237 }
28238 }
28239 {
28240 PyThreadState* __tstate = wxPyBeginAllowThreads();
28241 result = (bool)(arg1)->Enable(arg2);
28242
28243 wxPyEndAllowThreads(__tstate);
28244 if (PyErr_Occurred()) SWIG_fail;
28245 }
28246 {
28247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28248 }
28249 return resultobj;
28250 fail:
28251 return NULL;
28252 }
28253
28254
28255 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
28256 PyObject *resultobj = NULL;
28257 wxWindow *arg1 = (wxWindow *) 0 ;
28258 bool result;
28259 PyObject * obj0 = 0 ;
28260 char *kwnames[] = {
28261 (char *) "self", NULL
28262 };
28263
28264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
28265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28266 if (SWIG_arg_fail(1)) SWIG_fail;
28267 {
28268 PyThreadState* __tstate = wxPyBeginAllowThreads();
28269 result = (bool)(arg1)->Disable();
28270
28271 wxPyEndAllowThreads(__tstate);
28272 if (PyErr_Occurred()) SWIG_fail;
28273 }
28274 {
28275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28276 }
28277 return resultobj;
28278 fail:
28279 return NULL;
28280 }
28281
28282
28283 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
28284 PyObject *resultobj = NULL;
28285 wxWindow *arg1 = (wxWindow *) 0 ;
28286 bool result;
28287 PyObject * obj0 = 0 ;
28288 char *kwnames[] = {
28289 (char *) "self", NULL
28290 };
28291
28292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
28293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28294 if (SWIG_arg_fail(1)) SWIG_fail;
28295 {
28296 PyThreadState* __tstate = wxPyBeginAllowThreads();
28297 result = (bool)((wxWindow const *)arg1)->IsShown();
28298
28299 wxPyEndAllowThreads(__tstate);
28300 if (PyErr_Occurred()) SWIG_fail;
28301 }
28302 {
28303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28304 }
28305 return resultobj;
28306 fail:
28307 return NULL;
28308 }
28309
28310
28311 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28312 PyObject *resultobj = NULL;
28313 wxWindow *arg1 = (wxWindow *) 0 ;
28314 bool result;
28315 PyObject * obj0 = 0 ;
28316 char *kwnames[] = {
28317 (char *) "self", NULL
28318 };
28319
28320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
28321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28322 if (SWIG_arg_fail(1)) SWIG_fail;
28323 {
28324 PyThreadState* __tstate = wxPyBeginAllowThreads();
28325 result = (bool)((wxWindow const *)arg1)->IsEnabled();
28326
28327 wxPyEndAllowThreads(__tstate);
28328 if (PyErr_Occurred()) SWIG_fail;
28329 }
28330 {
28331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28332 }
28333 return resultobj;
28334 fail:
28335 return NULL;
28336 }
28337
28338
28339 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28340 PyObject *resultobj = NULL;
28341 wxWindow *arg1 = (wxWindow *) 0 ;
28342 long arg2 ;
28343 PyObject * obj0 = 0 ;
28344 PyObject * obj1 = 0 ;
28345 char *kwnames[] = {
28346 (char *) "self",(char *) "style", NULL
28347 };
28348
28349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
28350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28351 if (SWIG_arg_fail(1)) SWIG_fail;
28352 {
28353 arg2 = static_cast<long >(SWIG_As_long(obj1));
28354 if (SWIG_arg_fail(2)) SWIG_fail;
28355 }
28356 {
28357 PyThreadState* __tstate = wxPyBeginAllowThreads();
28358 (arg1)->SetWindowStyleFlag(arg2);
28359
28360 wxPyEndAllowThreads(__tstate);
28361 if (PyErr_Occurred()) SWIG_fail;
28362 }
28363 Py_INCREF(Py_None); resultobj = Py_None;
28364 return resultobj;
28365 fail:
28366 return NULL;
28367 }
28368
28369
28370 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28371 PyObject *resultobj = NULL;
28372 wxWindow *arg1 = (wxWindow *) 0 ;
28373 long result;
28374 PyObject * obj0 = 0 ;
28375 char *kwnames[] = {
28376 (char *) "self", NULL
28377 };
28378
28379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
28380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28381 if (SWIG_arg_fail(1)) SWIG_fail;
28382 {
28383 PyThreadState* __tstate = wxPyBeginAllowThreads();
28384 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
28385
28386 wxPyEndAllowThreads(__tstate);
28387 if (PyErr_Occurred()) SWIG_fail;
28388 }
28389 {
28390 resultobj = SWIG_From_long(static_cast<long >(result));
28391 }
28392 return resultobj;
28393 fail:
28394 return NULL;
28395 }
28396
28397
28398 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28399 PyObject *resultobj = NULL;
28400 wxWindow *arg1 = (wxWindow *) 0 ;
28401 int arg2 ;
28402 bool result;
28403 PyObject * obj0 = 0 ;
28404 PyObject * obj1 = 0 ;
28405 char *kwnames[] = {
28406 (char *) "self",(char *) "flag", NULL
28407 };
28408
28409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
28410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28411 if (SWIG_arg_fail(1)) SWIG_fail;
28412 {
28413 arg2 = static_cast<int >(SWIG_As_int(obj1));
28414 if (SWIG_arg_fail(2)) SWIG_fail;
28415 }
28416 {
28417 PyThreadState* __tstate = wxPyBeginAllowThreads();
28418 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
28419
28420 wxPyEndAllowThreads(__tstate);
28421 if (PyErr_Occurred()) SWIG_fail;
28422 }
28423 {
28424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28425 }
28426 return resultobj;
28427 fail:
28428 return NULL;
28429 }
28430
28431
28432 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
28433 PyObject *resultobj = NULL;
28434 wxWindow *arg1 = (wxWindow *) 0 ;
28435 bool result;
28436 PyObject * obj0 = 0 ;
28437 char *kwnames[] = {
28438 (char *) "self", NULL
28439 };
28440
28441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
28442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28443 if (SWIG_arg_fail(1)) SWIG_fail;
28444 {
28445 PyThreadState* __tstate = wxPyBeginAllowThreads();
28446 result = (bool)((wxWindow const *)arg1)->IsRetained();
28447
28448 wxPyEndAllowThreads(__tstate);
28449 if (PyErr_Occurred()) SWIG_fail;
28450 }
28451 {
28452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28453 }
28454 return resultobj;
28455 fail:
28456 return NULL;
28457 }
28458
28459
28460 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28461 PyObject *resultobj = NULL;
28462 wxWindow *arg1 = (wxWindow *) 0 ;
28463 long arg2 ;
28464 PyObject * obj0 = 0 ;
28465 PyObject * obj1 = 0 ;
28466 char *kwnames[] = {
28467 (char *) "self",(char *) "exStyle", NULL
28468 };
28469
28470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
28471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28472 if (SWIG_arg_fail(1)) SWIG_fail;
28473 {
28474 arg2 = static_cast<long >(SWIG_As_long(obj1));
28475 if (SWIG_arg_fail(2)) SWIG_fail;
28476 }
28477 {
28478 PyThreadState* __tstate = wxPyBeginAllowThreads();
28479 (arg1)->SetExtraStyle(arg2);
28480
28481 wxPyEndAllowThreads(__tstate);
28482 if (PyErr_Occurred()) SWIG_fail;
28483 }
28484 Py_INCREF(Py_None); resultobj = Py_None;
28485 return resultobj;
28486 fail:
28487 return NULL;
28488 }
28489
28490
28491 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28492 PyObject *resultobj = NULL;
28493 wxWindow *arg1 = (wxWindow *) 0 ;
28494 long result;
28495 PyObject * obj0 = 0 ;
28496 char *kwnames[] = {
28497 (char *) "self", NULL
28498 };
28499
28500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
28501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28502 if (SWIG_arg_fail(1)) SWIG_fail;
28503 {
28504 PyThreadState* __tstate = wxPyBeginAllowThreads();
28505 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
28506
28507 wxPyEndAllowThreads(__tstate);
28508 if (PyErr_Occurred()) SWIG_fail;
28509 }
28510 {
28511 resultobj = SWIG_From_long(static_cast<long >(result));
28512 }
28513 return resultobj;
28514 fail:
28515 return NULL;
28516 }
28517
28518
28519 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
28520 PyObject *resultobj = NULL;
28521 wxWindow *arg1 = (wxWindow *) 0 ;
28522 bool arg2 = (bool) true ;
28523 PyObject * obj0 = 0 ;
28524 PyObject * obj1 = 0 ;
28525 char *kwnames[] = {
28526 (char *) "self",(char *) "modal", NULL
28527 };
28528
28529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
28530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28531 if (SWIG_arg_fail(1)) SWIG_fail;
28532 if (obj1) {
28533 {
28534 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28535 if (SWIG_arg_fail(2)) SWIG_fail;
28536 }
28537 }
28538 {
28539 PyThreadState* __tstate = wxPyBeginAllowThreads();
28540 (arg1)->MakeModal(arg2);
28541
28542 wxPyEndAllowThreads(__tstate);
28543 if (PyErr_Occurred()) SWIG_fail;
28544 }
28545 Py_INCREF(Py_None); resultobj = Py_None;
28546 return resultobj;
28547 fail:
28548 return NULL;
28549 }
28550
28551
28552 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28553 PyObject *resultobj = NULL;
28554 wxWindow *arg1 = (wxWindow *) 0 ;
28555 bool arg2 ;
28556 PyObject * obj0 = 0 ;
28557 PyObject * obj1 = 0 ;
28558 char *kwnames[] = {
28559 (char *) "self",(char *) "enableTheme", NULL
28560 };
28561
28562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
28563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28564 if (SWIG_arg_fail(1)) SWIG_fail;
28565 {
28566 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28567 if (SWIG_arg_fail(2)) SWIG_fail;
28568 }
28569 {
28570 PyThreadState* __tstate = wxPyBeginAllowThreads();
28571 (arg1)->SetThemeEnabled(arg2);
28572
28573 wxPyEndAllowThreads(__tstate);
28574 if (PyErr_Occurred()) SWIG_fail;
28575 }
28576 Py_INCREF(Py_None); resultobj = Py_None;
28577 return resultobj;
28578 fail:
28579 return NULL;
28580 }
28581
28582
28583 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28584 PyObject *resultobj = NULL;
28585 wxWindow *arg1 = (wxWindow *) 0 ;
28586 bool result;
28587 PyObject * obj0 = 0 ;
28588 char *kwnames[] = {
28589 (char *) "self", NULL
28590 };
28591
28592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
28593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28594 if (SWIG_arg_fail(1)) SWIG_fail;
28595 {
28596 PyThreadState* __tstate = wxPyBeginAllowThreads();
28597 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
28598
28599 wxPyEndAllowThreads(__tstate);
28600 if (PyErr_Occurred()) SWIG_fail;
28601 }
28602 {
28603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28604 }
28605 return resultobj;
28606 fail:
28607 return NULL;
28608 }
28609
28610
28611 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28612 PyObject *resultobj = NULL;
28613 wxWindow *arg1 = (wxWindow *) 0 ;
28614 PyObject * obj0 = 0 ;
28615 char *kwnames[] = {
28616 (char *) "self", NULL
28617 };
28618
28619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
28620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28621 if (SWIG_arg_fail(1)) SWIG_fail;
28622 {
28623 PyThreadState* __tstate = wxPyBeginAllowThreads();
28624 (arg1)->SetFocus();
28625
28626 wxPyEndAllowThreads(__tstate);
28627 if (PyErr_Occurred()) SWIG_fail;
28628 }
28629 Py_INCREF(Py_None); resultobj = Py_None;
28630 return resultobj;
28631 fail:
28632 return NULL;
28633 }
28634
28635
28636 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
28637 PyObject *resultobj = NULL;
28638 wxWindow *arg1 = (wxWindow *) 0 ;
28639 PyObject * obj0 = 0 ;
28640 char *kwnames[] = {
28641 (char *) "self", NULL
28642 };
28643
28644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
28645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28646 if (SWIG_arg_fail(1)) SWIG_fail;
28647 {
28648 PyThreadState* __tstate = wxPyBeginAllowThreads();
28649 (arg1)->SetFocusFromKbd();
28650
28651 wxPyEndAllowThreads(__tstate);
28652 if (PyErr_Occurred()) SWIG_fail;
28653 }
28654 Py_INCREF(Py_None); resultobj = Py_None;
28655 return resultobj;
28656 fail:
28657 return NULL;
28658 }
28659
28660
28661 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28662 PyObject *resultobj = NULL;
28663 wxWindow *result;
28664 char *kwnames[] = {
28665 NULL
28666 };
28667
28668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
28669 {
28670 if (!wxPyCheckForApp()) SWIG_fail;
28671 PyThreadState* __tstate = wxPyBeginAllowThreads();
28672 result = (wxWindow *)wxWindow::FindFocus();
28673
28674 wxPyEndAllowThreads(__tstate);
28675 if (PyErr_Occurred()) SWIG_fail;
28676 }
28677 {
28678 resultobj = wxPyMake_wxObject(result, 0);
28679 }
28680 return resultobj;
28681 fail:
28682 return NULL;
28683 }
28684
28685
28686 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28687 PyObject *resultobj = NULL;
28688 wxWindow *arg1 = (wxWindow *) 0 ;
28689 bool result;
28690 PyObject * obj0 = 0 ;
28691 char *kwnames[] = {
28692 (char *) "self", NULL
28693 };
28694
28695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
28696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28697 if (SWIG_arg_fail(1)) SWIG_fail;
28698 {
28699 PyThreadState* __tstate = wxPyBeginAllowThreads();
28700 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
28701
28702 wxPyEndAllowThreads(__tstate);
28703 if (PyErr_Occurred()) SWIG_fail;
28704 }
28705 {
28706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28707 }
28708 return resultobj;
28709 fail:
28710 return NULL;
28711 }
28712
28713
28714 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
28715 PyObject *resultobj = NULL;
28716 wxWindow *arg1 = (wxWindow *) 0 ;
28717 bool result;
28718 PyObject * obj0 = 0 ;
28719 char *kwnames[] = {
28720 (char *) "self", NULL
28721 };
28722
28723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
28724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28725 if (SWIG_arg_fail(1)) SWIG_fail;
28726 {
28727 PyThreadState* __tstate = wxPyBeginAllowThreads();
28728 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
28729
28730 wxPyEndAllowThreads(__tstate);
28731 if (PyErr_Occurred()) SWIG_fail;
28732 }
28733 {
28734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28735 }
28736 return resultobj;
28737 fail:
28738 return NULL;
28739 }
28740
28741
28742 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28743 PyObject *resultobj = NULL;
28744 wxWindow *arg1 = (wxWindow *) 0 ;
28745 wxWindow *result;
28746 PyObject * obj0 = 0 ;
28747 char *kwnames[] = {
28748 (char *) "self", NULL
28749 };
28750
28751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
28752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28753 if (SWIG_arg_fail(1)) SWIG_fail;
28754 {
28755 PyThreadState* __tstate = wxPyBeginAllowThreads();
28756 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
28757
28758 wxPyEndAllowThreads(__tstate);
28759 if (PyErr_Occurred()) SWIG_fail;
28760 }
28761 {
28762 resultobj = wxPyMake_wxObject(result, 0);
28763 }
28764 return resultobj;
28765 fail:
28766 return NULL;
28767 }
28768
28769
28770 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28771 PyObject *resultobj = NULL;
28772 wxWindow *arg1 = (wxWindow *) 0 ;
28773 wxWindow *arg2 = (wxWindow *) 0 ;
28774 wxWindow *result;
28775 PyObject * obj0 = 0 ;
28776 PyObject * obj1 = 0 ;
28777 char *kwnames[] = {
28778 (char *) "self",(char *) "child", NULL
28779 };
28780
28781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28783 if (SWIG_arg_fail(1)) SWIG_fail;
28784 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28785 if (SWIG_arg_fail(2)) SWIG_fail;
28786 {
28787 PyThreadState* __tstate = wxPyBeginAllowThreads();
28788 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
28789
28790 wxPyEndAllowThreads(__tstate);
28791 if (PyErr_Occurred()) SWIG_fail;
28792 }
28793 {
28794 resultobj = wxPyMake_wxObject(result, 0);
28795 }
28796 return resultobj;
28797 fail:
28798 return NULL;
28799 }
28800
28801
28802 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28803 PyObject *resultobj = NULL;
28804 wxWindow *arg1 = (wxWindow *) 0 ;
28805 wxWindow *arg2 = (wxWindow *) 0 ;
28806 PyObject * obj0 = 0 ;
28807 PyObject * obj1 = 0 ;
28808 char *kwnames[] = {
28809 (char *) "self",(char *) "win", NULL
28810 };
28811
28812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28814 if (SWIG_arg_fail(1)) SWIG_fail;
28815 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28816 if (SWIG_arg_fail(2)) SWIG_fail;
28817 {
28818 PyThreadState* __tstate = wxPyBeginAllowThreads();
28819 (arg1)->SetTmpDefaultItem(arg2);
28820
28821 wxPyEndAllowThreads(__tstate);
28822 if (PyErr_Occurred()) SWIG_fail;
28823 }
28824 Py_INCREF(Py_None); resultobj = Py_None;
28825 return resultobj;
28826 fail:
28827 return NULL;
28828 }
28829
28830
28831 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28832 PyObject *resultobj = NULL;
28833 wxWindow *arg1 = (wxWindow *) 0 ;
28834 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28835 bool result;
28836 PyObject * obj0 = 0 ;
28837 PyObject * obj1 = 0 ;
28838 char *kwnames[] = {
28839 (char *) "self",(char *) "flags", NULL
28840 };
28841
28842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28844 if (SWIG_arg_fail(1)) SWIG_fail;
28845 if (obj1) {
28846 {
28847 arg2 = static_cast<int >(SWIG_As_int(obj1));
28848 if (SWIG_arg_fail(2)) SWIG_fail;
28849 }
28850 }
28851 {
28852 PyThreadState* __tstate = wxPyBeginAllowThreads();
28853 result = (bool)(arg1)->Navigate(arg2);
28854
28855 wxPyEndAllowThreads(__tstate);
28856 if (PyErr_Occurred()) SWIG_fail;
28857 }
28858 {
28859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28860 }
28861 return resultobj;
28862 fail:
28863 return NULL;
28864 }
28865
28866
28867 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28868 PyObject *resultobj = NULL;
28869 wxWindow *arg1 = (wxWindow *) 0 ;
28870 wxWindow *arg2 = (wxWindow *) 0 ;
28871 PyObject * obj0 = 0 ;
28872 PyObject * obj1 = 0 ;
28873 char *kwnames[] = {
28874 (char *) "self",(char *) "win", NULL
28875 };
28876
28877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28879 if (SWIG_arg_fail(1)) SWIG_fail;
28880 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28881 if (SWIG_arg_fail(2)) SWIG_fail;
28882 {
28883 PyThreadState* __tstate = wxPyBeginAllowThreads();
28884 (arg1)->MoveAfterInTabOrder(arg2);
28885
28886 wxPyEndAllowThreads(__tstate);
28887 if (PyErr_Occurred()) SWIG_fail;
28888 }
28889 Py_INCREF(Py_None); resultobj = Py_None;
28890 return resultobj;
28891 fail:
28892 return NULL;
28893 }
28894
28895
28896 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28897 PyObject *resultobj = NULL;
28898 wxWindow *arg1 = (wxWindow *) 0 ;
28899 wxWindow *arg2 = (wxWindow *) 0 ;
28900 PyObject * obj0 = 0 ;
28901 PyObject * obj1 = 0 ;
28902 char *kwnames[] = {
28903 (char *) "self",(char *) "win", NULL
28904 };
28905
28906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28908 if (SWIG_arg_fail(1)) SWIG_fail;
28909 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28910 if (SWIG_arg_fail(2)) SWIG_fail;
28911 {
28912 PyThreadState* __tstate = wxPyBeginAllowThreads();
28913 (arg1)->MoveBeforeInTabOrder(arg2);
28914
28915 wxPyEndAllowThreads(__tstate);
28916 if (PyErr_Occurred()) SWIG_fail;
28917 }
28918 Py_INCREF(Py_None); resultobj = Py_None;
28919 return resultobj;
28920 fail:
28921 return NULL;
28922 }
28923
28924
28925 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28926 PyObject *resultobj = NULL;
28927 wxWindow *arg1 = (wxWindow *) 0 ;
28928 PyObject *result;
28929 PyObject * obj0 = 0 ;
28930 char *kwnames[] = {
28931 (char *) "self", NULL
28932 };
28933
28934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28936 if (SWIG_arg_fail(1)) SWIG_fail;
28937 {
28938 PyThreadState* __tstate = wxPyBeginAllowThreads();
28939 result = (PyObject *)wxWindow_GetChildren(arg1);
28940
28941 wxPyEndAllowThreads(__tstate);
28942 if (PyErr_Occurred()) SWIG_fail;
28943 }
28944 resultobj = result;
28945 return resultobj;
28946 fail:
28947 return NULL;
28948 }
28949
28950
28951 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28952 PyObject *resultobj = NULL;
28953 wxWindow *arg1 = (wxWindow *) 0 ;
28954 wxWindow *result;
28955 PyObject * obj0 = 0 ;
28956 char *kwnames[] = {
28957 (char *) "self", NULL
28958 };
28959
28960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28962 if (SWIG_arg_fail(1)) SWIG_fail;
28963 {
28964 PyThreadState* __tstate = wxPyBeginAllowThreads();
28965 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28966
28967 wxPyEndAllowThreads(__tstate);
28968 if (PyErr_Occurred()) SWIG_fail;
28969 }
28970 {
28971 resultobj = wxPyMake_wxObject(result, 0);
28972 }
28973 return resultobj;
28974 fail:
28975 return NULL;
28976 }
28977
28978
28979 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28980 PyObject *resultobj = NULL;
28981 wxWindow *arg1 = (wxWindow *) 0 ;
28982 wxWindow *result;
28983 PyObject * obj0 = 0 ;
28984 char *kwnames[] = {
28985 (char *) "self", NULL
28986 };
28987
28988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28990 if (SWIG_arg_fail(1)) SWIG_fail;
28991 {
28992 PyThreadState* __tstate = wxPyBeginAllowThreads();
28993 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28994
28995 wxPyEndAllowThreads(__tstate);
28996 if (PyErr_Occurred()) SWIG_fail;
28997 }
28998 {
28999 resultobj = wxPyMake_wxObject(result, 0);
29000 }
29001 return resultobj;
29002 fail:
29003 return NULL;
29004 }
29005
29006
29007 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
29008 PyObject *resultobj = NULL;
29009 wxWindow *arg1 = (wxWindow *) 0 ;
29010 bool result;
29011 PyObject * obj0 = 0 ;
29012 char *kwnames[] = {
29013 (char *) "self", NULL
29014 };
29015
29016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
29017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29018 if (SWIG_arg_fail(1)) SWIG_fail;
29019 {
29020 PyThreadState* __tstate = wxPyBeginAllowThreads();
29021 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
29022
29023 wxPyEndAllowThreads(__tstate);
29024 if (PyErr_Occurred()) SWIG_fail;
29025 }
29026 {
29027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29028 }
29029 return resultobj;
29030 fail:
29031 return NULL;
29032 }
29033
29034
29035 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
29036 PyObject *resultobj = NULL;
29037 wxWindow *arg1 = (wxWindow *) 0 ;
29038 wxWindow *arg2 = (wxWindow *) 0 ;
29039 bool result;
29040 PyObject * obj0 = 0 ;
29041 PyObject * obj1 = 0 ;
29042 char *kwnames[] = {
29043 (char *) "self",(char *) "newParent", NULL
29044 };
29045
29046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
29047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29048 if (SWIG_arg_fail(1)) SWIG_fail;
29049 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29050 if (SWIG_arg_fail(2)) SWIG_fail;
29051 {
29052 PyThreadState* __tstate = wxPyBeginAllowThreads();
29053 result = (bool)(arg1)->Reparent(arg2);
29054
29055 wxPyEndAllowThreads(__tstate);
29056 if (PyErr_Occurred()) SWIG_fail;
29057 }
29058 {
29059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29060 }
29061 return resultobj;
29062 fail:
29063 return NULL;
29064 }
29065
29066
29067 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
29068 PyObject *resultobj = NULL;
29069 wxWindow *arg1 = (wxWindow *) 0 ;
29070 wxWindow *arg2 = (wxWindow *) 0 ;
29071 PyObject * obj0 = 0 ;
29072 PyObject * obj1 = 0 ;
29073 char *kwnames[] = {
29074 (char *) "self",(char *) "child", NULL
29075 };
29076
29077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
29078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29079 if (SWIG_arg_fail(1)) SWIG_fail;
29080 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29081 if (SWIG_arg_fail(2)) SWIG_fail;
29082 {
29083 PyThreadState* __tstate = wxPyBeginAllowThreads();
29084 (arg1)->AddChild(arg2);
29085
29086 wxPyEndAllowThreads(__tstate);
29087 if (PyErr_Occurred()) SWIG_fail;
29088 }
29089 Py_INCREF(Py_None); resultobj = Py_None;
29090 return resultobj;
29091 fail:
29092 return NULL;
29093 }
29094
29095
29096 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
29097 PyObject *resultobj = NULL;
29098 wxWindow *arg1 = (wxWindow *) 0 ;
29099 wxWindow *arg2 = (wxWindow *) 0 ;
29100 PyObject * obj0 = 0 ;
29101 PyObject * obj1 = 0 ;
29102 char *kwnames[] = {
29103 (char *) "self",(char *) "child", NULL
29104 };
29105
29106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
29107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29108 if (SWIG_arg_fail(1)) SWIG_fail;
29109 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29110 if (SWIG_arg_fail(2)) SWIG_fail;
29111 {
29112 PyThreadState* __tstate = wxPyBeginAllowThreads();
29113 (arg1)->RemoveChild(arg2);
29114
29115 wxPyEndAllowThreads(__tstate);
29116 if (PyErr_Occurred()) SWIG_fail;
29117 }
29118 Py_INCREF(Py_None); resultobj = Py_None;
29119 return resultobj;
29120 fail:
29121 return NULL;
29122 }
29123
29124
29125 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
29126 PyObject *resultobj = NULL;
29127 wxWindow *arg1 = (wxWindow *) 0 ;
29128 long arg2 ;
29129 wxWindow *result;
29130 PyObject * obj0 = 0 ;
29131 PyObject * obj1 = 0 ;
29132 char *kwnames[] = {
29133 (char *) "self",(char *) "winid", NULL
29134 };
29135
29136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
29137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29138 if (SWIG_arg_fail(1)) SWIG_fail;
29139 {
29140 arg2 = static_cast<long >(SWIG_As_long(obj1));
29141 if (SWIG_arg_fail(2)) SWIG_fail;
29142 }
29143 {
29144 PyThreadState* __tstate = wxPyBeginAllowThreads();
29145 result = (wxWindow *)(arg1)->FindWindow(arg2);
29146
29147 wxPyEndAllowThreads(__tstate);
29148 if (PyErr_Occurred()) SWIG_fail;
29149 }
29150 {
29151 resultobj = wxPyMake_wxObject(result, 0);
29152 }
29153 return resultobj;
29154 fail:
29155 return NULL;
29156 }
29157
29158
29159 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
29160 PyObject *resultobj = NULL;
29161 wxWindow *arg1 = (wxWindow *) 0 ;
29162 wxString *arg2 = 0 ;
29163 wxWindow *result;
29164 bool temp2 = false ;
29165 PyObject * obj0 = 0 ;
29166 PyObject * obj1 = 0 ;
29167 char *kwnames[] = {
29168 (char *) "self",(char *) "name", NULL
29169 };
29170
29171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
29172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29173 if (SWIG_arg_fail(1)) SWIG_fail;
29174 {
29175 arg2 = wxString_in_helper(obj1);
29176 if (arg2 == NULL) SWIG_fail;
29177 temp2 = true;
29178 }
29179 {
29180 PyThreadState* __tstate = wxPyBeginAllowThreads();
29181 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
29182
29183 wxPyEndAllowThreads(__tstate);
29184 if (PyErr_Occurred()) SWIG_fail;
29185 }
29186 {
29187 resultobj = wxPyMake_wxObject(result, 0);
29188 }
29189 {
29190 if (temp2)
29191 delete arg2;
29192 }
29193 return resultobj;
29194 fail:
29195 {
29196 if (temp2)
29197 delete arg2;
29198 }
29199 return NULL;
29200 }
29201
29202
29203 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29204 PyObject *resultobj = NULL;
29205 wxWindow *arg1 = (wxWindow *) 0 ;
29206 wxEvtHandler *result;
29207 PyObject * obj0 = 0 ;
29208 char *kwnames[] = {
29209 (char *) "self", NULL
29210 };
29211
29212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
29213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29214 if (SWIG_arg_fail(1)) SWIG_fail;
29215 {
29216 PyThreadState* __tstate = wxPyBeginAllowThreads();
29217 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
29218
29219 wxPyEndAllowThreads(__tstate);
29220 if (PyErr_Occurred()) SWIG_fail;
29221 }
29222 {
29223 resultobj = wxPyMake_wxObject(result, 0);
29224 }
29225 return resultobj;
29226 fail:
29227 return NULL;
29228 }
29229
29230
29231 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29232 PyObject *resultobj = NULL;
29233 wxWindow *arg1 = (wxWindow *) 0 ;
29234 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29235 PyObject * obj0 = 0 ;
29236 PyObject * obj1 = 0 ;
29237 char *kwnames[] = {
29238 (char *) "self",(char *) "handler", NULL
29239 };
29240
29241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
29242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29243 if (SWIG_arg_fail(1)) SWIG_fail;
29244 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29245 if (SWIG_arg_fail(2)) SWIG_fail;
29246 {
29247 PyThreadState* __tstate = wxPyBeginAllowThreads();
29248 (arg1)->SetEventHandler(arg2);
29249
29250 wxPyEndAllowThreads(__tstate);
29251 if (PyErr_Occurred()) SWIG_fail;
29252 }
29253 Py_INCREF(Py_None); resultobj = Py_None;
29254 return resultobj;
29255 fail:
29256 return NULL;
29257 }
29258
29259
29260 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29261 PyObject *resultobj = NULL;
29262 wxWindow *arg1 = (wxWindow *) 0 ;
29263 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29264 PyObject * obj0 = 0 ;
29265 PyObject * obj1 = 0 ;
29266 char *kwnames[] = {
29267 (char *) "self",(char *) "handler", NULL
29268 };
29269
29270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
29271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29272 if (SWIG_arg_fail(1)) SWIG_fail;
29273 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29274 if (SWIG_arg_fail(2)) SWIG_fail;
29275 {
29276 PyThreadState* __tstate = wxPyBeginAllowThreads();
29277 (arg1)->PushEventHandler(arg2);
29278
29279 wxPyEndAllowThreads(__tstate);
29280 if (PyErr_Occurred()) SWIG_fail;
29281 }
29282 Py_INCREF(Py_None); resultobj = Py_None;
29283 return resultobj;
29284 fail:
29285 return NULL;
29286 }
29287
29288
29289 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29290 PyObject *resultobj = NULL;
29291 wxWindow *arg1 = (wxWindow *) 0 ;
29292 bool arg2 = (bool) false ;
29293 wxEvtHandler *result;
29294 PyObject * obj0 = 0 ;
29295 PyObject * obj1 = 0 ;
29296 char *kwnames[] = {
29297 (char *) "self",(char *) "deleteHandler", NULL
29298 };
29299
29300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
29301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29302 if (SWIG_arg_fail(1)) SWIG_fail;
29303 if (obj1) {
29304 {
29305 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
29306 if (SWIG_arg_fail(2)) SWIG_fail;
29307 }
29308 }
29309 {
29310 PyThreadState* __tstate = wxPyBeginAllowThreads();
29311 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
29312
29313 wxPyEndAllowThreads(__tstate);
29314 if (PyErr_Occurred()) SWIG_fail;
29315 }
29316 {
29317 resultobj = wxPyMake_wxObject(result, 0);
29318 }
29319 return resultobj;
29320 fail:
29321 return NULL;
29322 }
29323
29324
29325 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29326 PyObject *resultobj = NULL;
29327 wxWindow *arg1 = (wxWindow *) 0 ;
29328 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29329 bool result;
29330 PyObject * obj0 = 0 ;
29331 PyObject * obj1 = 0 ;
29332 char *kwnames[] = {
29333 (char *) "self",(char *) "handler", NULL
29334 };
29335
29336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
29337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29338 if (SWIG_arg_fail(1)) SWIG_fail;
29339 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29340 if (SWIG_arg_fail(2)) SWIG_fail;
29341 {
29342 PyThreadState* __tstate = wxPyBeginAllowThreads();
29343 result = (bool)(arg1)->RemoveEventHandler(arg2);
29344
29345 wxPyEndAllowThreads(__tstate);
29346 if (PyErr_Occurred()) SWIG_fail;
29347 }
29348 {
29349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29350 }
29351 return resultobj;
29352 fail:
29353 return NULL;
29354 }
29355
29356
29357 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29358 PyObject *resultobj = NULL;
29359 wxWindow *arg1 = (wxWindow *) 0 ;
29360 wxValidator *arg2 = 0 ;
29361 PyObject * obj0 = 0 ;
29362 PyObject * obj1 = 0 ;
29363 char *kwnames[] = {
29364 (char *) "self",(char *) "validator", NULL
29365 };
29366
29367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
29368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29369 if (SWIG_arg_fail(1)) SWIG_fail;
29370 {
29371 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
29372 if (SWIG_arg_fail(2)) SWIG_fail;
29373 if (arg2 == NULL) {
29374 SWIG_null_ref("wxValidator");
29375 }
29376 if (SWIG_arg_fail(2)) SWIG_fail;
29377 }
29378 {
29379 PyThreadState* __tstate = wxPyBeginAllowThreads();
29380 (arg1)->SetValidator((wxValidator const &)*arg2);
29381
29382 wxPyEndAllowThreads(__tstate);
29383 if (PyErr_Occurred()) SWIG_fail;
29384 }
29385 Py_INCREF(Py_None); resultobj = Py_None;
29386 return resultobj;
29387 fail:
29388 return NULL;
29389 }
29390
29391
29392 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29393 PyObject *resultobj = NULL;
29394 wxWindow *arg1 = (wxWindow *) 0 ;
29395 wxValidator *result;
29396 PyObject * obj0 = 0 ;
29397 char *kwnames[] = {
29398 (char *) "self", NULL
29399 };
29400
29401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
29402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29403 if (SWIG_arg_fail(1)) SWIG_fail;
29404 {
29405 PyThreadState* __tstate = wxPyBeginAllowThreads();
29406 result = (wxValidator *)(arg1)->GetValidator();
29407
29408 wxPyEndAllowThreads(__tstate);
29409 if (PyErr_Occurred()) SWIG_fail;
29410 }
29411 {
29412 resultobj = wxPyMake_wxObject(result, (bool)0);
29413 }
29414 return resultobj;
29415 fail:
29416 return NULL;
29417 }
29418
29419
29420 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
29421 PyObject *resultobj = NULL;
29422 wxWindow *arg1 = (wxWindow *) 0 ;
29423 bool result;
29424 PyObject * obj0 = 0 ;
29425 char *kwnames[] = {
29426 (char *) "self", NULL
29427 };
29428
29429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
29430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29431 if (SWIG_arg_fail(1)) SWIG_fail;
29432 {
29433 PyThreadState* __tstate = wxPyBeginAllowThreads();
29434 result = (bool)(arg1)->Validate();
29435
29436 wxPyEndAllowThreads(__tstate);
29437 if (PyErr_Occurred()) SWIG_fail;
29438 }
29439 {
29440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29441 }
29442 return resultobj;
29443 fail:
29444 return NULL;
29445 }
29446
29447
29448 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29449 PyObject *resultobj = NULL;
29450 wxWindow *arg1 = (wxWindow *) 0 ;
29451 bool result;
29452 PyObject * obj0 = 0 ;
29453 char *kwnames[] = {
29454 (char *) "self", NULL
29455 };
29456
29457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
29458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29459 if (SWIG_arg_fail(1)) SWIG_fail;
29460 {
29461 PyThreadState* __tstate = wxPyBeginAllowThreads();
29462 result = (bool)(arg1)->TransferDataToWindow();
29463
29464 wxPyEndAllowThreads(__tstate);
29465 if (PyErr_Occurred()) SWIG_fail;
29466 }
29467 {
29468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29469 }
29470 return resultobj;
29471 fail:
29472 return NULL;
29473 }
29474
29475
29476 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29477 PyObject *resultobj = NULL;
29478 wxWindow *arg1 = (wxWindow *) 0 ;
29479 bool result;
29480 PyObject * obj0 = 0 ;
29481 char *kwnames[] = {
29482 (char *) "self", NULL
29483 };
29484
29485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
29486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29487 if (SWIG_arg_fail(1)) SWIG_fail;
29488 {
29489 PyThreadState* __tstate = wxPyBeginAllowThreads();
29490 result = (bool)(arg1)->TransferDataFromWindow();
29491
29492 wxPyEndAllowThreads(__tstate);
29493 if (PyErr_Occurred()) SWIG_fail;
29494 }
29495 {
29496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29497 }
29498 return resultobj;
29499 fail:
29500 return NULL;
29501 }
29502
29503
29504 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29505 PyObject *resultobj = NULL;
29506 wxWindow *arg1 = (wxWindow *) 0 ;
29507 PyObject * obj0 = 0 ;
29508 char *kwnames[] = {
29509 (char *) "self", NULL
29510 };
29511
29512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
29513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29514 if (SWIG_arg_fail(1)) SWIG_fail;
29515 {
29516 PyThreadState* __tstate = wxPyBeginAllowThreads();
29517 (arg1)->InitDialog();
29518
29519 wxPyEndAllowThreads(__tstate);
29520 if (PyErr_Occurred()) SWIG_fail;
29521 }
29522 Py_INCREF(Py_None); resultobj = Py_None;
29523 return resultobj;
29524 fail:
29525 return NULL;
29526 }
29527
29528
29529 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29530 PyObject *resultobj = NULL;
29531 wxWindow *arg1 = (wxWindow *) 0 ;
29532 wxAcceleratorTable *arg2 = 0 ;
29533 PyObject * obj0 = 0 ;
29534 PyObject * obj1 = 0 ;
29535 char *kwnames[] = {
29536 (char *) "self",(char *) "accel", NULL
29537 };
29538
29539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
29540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29541 if (SWIG_arg_fail(1)) SWIG_fail;
29542 {
29543 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
29544 if (SWIG_arg_fail(2)) SWIG_fail;
29545 if (arg2 == NULL) {
29546 SWIG_null_ref("wxAcceleratorTable");
29547 }
29548 if (SWIG_arg_fail(2)) SWIG_fail;
29549 }
29550 {
29551 PyThreadState* __tstate = wxPyBeginAllowThreads();
29552 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
29553
29554 wxPyEndAllowThreads(__tstate);
29555 if (PyErr_Occurred()) SWIG_fail;
29556 }
29557 Py_INCREF(Py_None); resultobj = Py_None;
29558 return resultobj;
29559 fail:
29560 return NULL;
29561 }
29562
29563
29564 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29565 PyObject *resultobj = NULL;
29566 wxWindow *arg1 = (wxWindow *) 0 ;
29567 wxAcceleratorTable *result;
29568 PyObject * obj0 = 0 ;
29569 char *kwnames[] = {
29570 (char *) "self", NULL
29571 };
29572
29573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
29574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29575 if (SWIG_arg_fail(1)) SWIG_fail;
29576 {
29577 PyThreadState* __tstate = wxPyBeginAllowThreads();
29578 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
29579
29580 wxPyEndAllowThreads(__tstate);
29581 if (PyErr_Occurred()) SWIG_fail;
29582 }
29583 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
29584 return resultobj;
29585 fail:
29586 return NULL;
29587 }
29588
29589
29590 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29591 PyObject *resultobj = NULL;
29592 wxWindow *arg1 = (wxWindow *) 0 ;
29593 int arg2 ;
29594 int arg3 ;
29595 int arg4 ;
29596 bool result;
29597 PyObject * obj0 = 0 ;
29598 PyObject * obj1 = 0 ;
29599 PyObject * obj2 = 0 ;
29600 PyObject * obj3 = 0 ;
29601 char *kwnames[] = {
29602 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
29603 };
29604
29605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29607 if (SWIG_arg_fail(1)) SWIG_fail;
29608 {
29609 arg2 = static_cast<int >(SWIG_As_int(obj1));
29610 if (SWIG_arg_fail(2)) SWIG_fail;
29611 }
29612 {
29613 arg3 = static_cast<int >(SWIG_As_int(obj2));
29614 if (SWIG_arg_fail(3)) SWIG_fail;
29615 }
29616 {
29617 arg4 = static_cast<int >(SWIG_As_int(obj3));
29618 if (SWIG_arg_fail(4)) SWIG_fail;
29619 }
29620 {
29621 PyThreadState* __tstate = wxPyBeginAllowThreads();
29622 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
29623
29624 wxPyEndAllowThreads(__tstate);
29625 if (PyErr_Occurred()) SWIG_fail;
29626 }
29627 {
29628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29629 }
29630 return resultobj;
29631 fail:
29632 return NULL;
29633 }
29634
29635
29636 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29637 PyObject *resultobj = NULL;
29638 wxWindow *arg1 = (wxWindow *) 0 ;
29639 int arg2 ;
29640 bool result;
29641 PyObject * obj0 = 0 ;
29642 PyObject * obj1 = 0 ;
29643 char *kwnames[] = {
29644 (char *) "self",(char *) "hotkeyId", NULL
29645 };
29646
29647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
29648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29649 if (SWIG_arg_fail(1)) SWIG_fail;
29650 {
29651 arg2 = static_cast<int >(SWIG_As_int(obj1));
29652 if (SWIG_arg_fail(2)) SWIG_fail;
29653 }
29654 {
29655 PyThreadState* __tstate = wxPyBeginAllowThreads();
29656 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
29657
29658 wxPyEndAllowThreads(__tstate);
29659 if (PyErr_Occurred()) SWIG_fail;
29660 }
29661 {
29662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29663 }
29664 return resultobj;
29665 fail:
29666 return NULL;
29667 }
29668
29669
29670 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29671 PyObject *resultobj = NULL;
29672 wxWindow *arg1 = (wxWindow *) 0 ;
29673 wxPoint *arg2 = 0 ;
29674 wxPoint result;
29675 wxPoint temp2 ;
29676 PyObject * obj0 = 0 ;
29677 PyObject * obj1 = 0 ;
29678 char *kwnames[] = {
29679 (char *) "self",(char *) "pt", NULL
29680 };
29681
29682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
29683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29684 if (SWIG_arg_fail(1)) SWIG_fail;
29685 {
29686 arg2 = &temp2;
29687 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29688 }
29689 {
29690 PyThreadState* __tstate = wxPyBeginAllowThreads();
29691 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29692
29693 wxPyEndAllowThreads(__tstate);
29694 if (PyErr_Occurred()) SWIG_fail;
29695 }
29696 {
29697 wxPoint * resultptr;
29698 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29699 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29700 }
29701 return resultobj;
29702 fail:
29703 return NULL;
29704 }
29705
29706
29707 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29708 PyObject *resultobj = NULL;
29709 wxWindow *arg1 = (wxWindow *) 0 ;
29710 wxSize *arg2 = 0 ;
29711 wxSize result;
29712 wxSize temp2 ;
29713 PyObject * obj0 = 0 ;
29714 PyObject * obj1 = 0 ;
29715 char *kwnames[] = {
29716 (char *) "self",(char *) "sz", NULL
29717 };
29718
29719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
29720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29721 if (SWIG_arg_fail(1)) SWIG_fail;
29722 {
29723 arg2 = &temp2;
29724 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29725 }
29726 {
29727 PyThreadState* __tstate = wxPyBeginAllowThreads();
29728 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29729
29730 wxPyEndAllowThreads(__tstate);
29731 if (PyErr_Occurred()) SWIG_fail;
29732 }
29733 {
29734 wxSize * resultptr;
29735 resultptr = new wxSize(static_cast<wxSize & >(result));
29736 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29737 }
29738 return resultobj;
29739 fail:
29740 return NULL;
29741 }
29742
29743
29744 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
29745 PyObject *resultobj = NULL;
29746 wxWindow *arg1 = (wxWindow *) 0 ;
29747 wxPoint *arg2 = 0 ;
29748 wxPoint result;
29749 wxPoint temp2 ;
29750 PyObject * obj0 = 0 ;
29751 PyObject * obj1 = 0 ;
29752 char *kwnames[] = {
29753 (char *) "self",(char *) "pt", NULL
29754 };
29755
29756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
29757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29758 if (SWIG_arg_fail(1)) SWIG_fail;
29759 {
29760 arg2 = &temp2;
29761 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29762 }
29763 {
29764 PyThreadState* __tstate = wxPyBeginAllowThreads();
29765 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29766
29767 wxPyEndAllowThreads(__tstate);
29768 if (PyErr_Occurred()) SWIG_fail;
29769 }
29770 {
29771 wxPoint * resultptr;
29772 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29773 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29774 }
29775 return resultobj;
29776 fail:
29777 return NULL;
29778 }
29779
29780
29781 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
29782 PyObject *resultobj = NULL;
29783 wxWindow *arg1 = (wxWindow *) 0 ;
29784 wxSize *arg2 = 0 ;
29785 wxSize result;
29786 wxSize temp2 ;
29787 PyObject * obj0 = 0 ;
29788 PyObject * obj1 = 0 ;
29789 char *kwnames[] = {
29790 (char *) "self",(char *) "sz", NULL
29791 };
29792
29793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29795 if (SWIG_arg_fail(1)) SWIG_fail;
29796 {
29797 arg2 = &temp2;
29798 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29799 }
29800 {
29801 PyThreadState* __tstate = wxPyBeginAllowThreads();
29802 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29803
29804 wxPyEndAllowThreads(__tstate);
29805 if (PyErr_Occurred()) SWIG_fail;
29806 }
29807 {
29808 wxSize * resultptr;
29809 resultptr = new wxSize(static_cast<wxSize & >(result));
29810 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29811 }
29812 return resultobj;
29813 fail:
29814 return NULL;
29815 }
29816
29817
29818 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29819 PyObject *resultobj = NULL;
29820 wxWindow *arg1 = (wxWindow *) 0 ;
29821 wxPoint *arg2 = 0 ;
29822 wxPoint result;
29823 wxPoint temp2 ;
29824 PyObject * obj0 = 0 ;
29825 PyObject * obj1 = 0 ;
29826 char *kwnames[] = {
29827 (char *) "self",(char *) "pt", NULL
29828 };
29829
29830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29832 if (SWIG_arg_fail(1)) SWIG_fail;
29833 {
29834 arg2 = &temp2;
29835 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29836 }
29837 {
29838 PyThreadState* __tstate = wxPyBeginAllowThreads();
29839 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29840
29841 wxPyEndAllowThreads(__tstate);
29842 if (PyErr_Occurred()) SWIG_fail;
29843 }
29844 {
29845 wxPoint * resultptr;
29846 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29847 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29848 }
29849 return resultobj;
29850 fail:
29851 return NULL;
29852 }
29853
29854
29855 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29856 PyObject *resultobj = NULL;
29857 wxWindow *arg1 = (wxWindow *) 0 ;
29858 wxSize *arg2 = 0 ;
29859 wxSize result;
29860 wxSize temp2 ;
29861 PyObject * obj0 = 0 ;
29862 PyObject * obj1 = 0 ;
29863 char *kwnames[] = {
29864 (char *) "self",(char *) "sz", NULL
29865 };
29866
29867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29869 if (SWIG_arg_fail(1)) SWIG_fail;
29870 {
29871 arg2 = &temp2;
29872 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29873 }
29874 {
29875 PyThreadState* __tstate = wxPyBeginAllowThreads();
29876 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29877
29878 wxPyEndAllowThreads(__tstate);
29879 if (PyErr_Occurred()) SWIG_fail;
29880 }
29881 {
29882 wxSize * resultptr;
29883 resultptr = new wxSize(static_cast<wxSize & >(result));
29884 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29885 }
29886 return resultobj;
29887 fail:
29888 return NULL;
29889 }
29890
29891
29892 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29893 PyObject *resultobj = NULL;
29894 wxWindow *arg1 = (wxWindow *) 0 ;
29895 int arg2 ;
29896 int arg3 ;
29897 PyObject * obj0 = 0 ;
29898 PyObject * obj1 = 0 ;
29899 PyObject * obj2 = 0 ;
29900 char *kwnames[] = {
29901 (char *) "self",(char *) "x",(char *) "y", NULL
29902 };
29903
29904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29906 if (SWIG_arg_fail(1)) SWIG_fail;
29907 {
29908 arg2 = static_cast<int >(SWIG_As_int(obj1));
29909 if (SWIG_arg_fail(2)) SWIG_fail;
29910 }
29911 {
29912 arg3 = static_cast<int >(SWIG_As_int(obj2));
29913 if (SWIG_arg_fail(3)) SWIG_fail;
29914 }
29915 {
29916 PyThreadState* __tstate = wxPyBeginAllowThreads();
29917 (arg1)->WarpPointer(arg2,arg3);
29918
29919 wxPyEndAllowThreads(__tstate);
29920 if (PyErr_Occurred()) SWIG_fail;
29921 }
29922 Py_INCREF(Py_None); resultobj = Py_None;
29923 return resultobj;
29924 fail:
29925 return NULL;
29926 }
29927
29928
29929 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29930 PyObject *resultobj = NULL;
29931 wxWindow *arg1 = (wxWindow *) 0 ;
29932 PyObject * obj0 = 0 ;
29933 char *kwnames[] = {
29934 (char *) "self", NULL
29935 };
29936
29937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29939 if (SWIG_arg_fail(1)) SWIG_fail;
29940 {
29941 PyThreadState* __tstate = wxPyBeginAllowThreads();
29942 (arg1)->CaptureMouse();
29943
29944 wxPyEndAllowThreads(__tstate);
29945 if (PyErr_Occurred()) SWIG_fail;
29946 }
29947 Py_INCREF(Py_None); resultobj = Py_None;
29948 return resultobj;
29949 fail:
29950 return NULL;
29951 }
29952
29953
29954 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29955 PyObject *resultobj = NULL;
29956 wxWindow *arg1 = (wxWindow *) 0 ;
29957 PyObject * obj0 = 0 ;
29958 char *kwnames[] = {
29959 (char *) "self", NULL
29960 };
29961
29962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29964 if (SWIG_arg_fail(1)) SWIG_fail;
29965 {
29966 PyThreadState* __tstate = wxPyBeginAllowThreads();
29967 (arg1)->ReleaseMouse();
29968
29969 wxPyEndAllowThreads(__tstate);
29970 if (PyErr_Occurred()) SWIG_fail;
29971 }
29972 Py_INCREF(Py_None); resultobj = Py_None;
29973 return resultobj;
29974 fail:
29975 return NULL;
29976 }
29977
29978
29979 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29980 PyObject *resultobj = NULL;
29981 wxWindow *result;
29982 char *kwnames[] = {
29983 NULL
29984 };
29985
29986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29987 {
29988 if (!wxPyCheckForApp()) SWIG_fail;
29989 PyThreadState* __tstate = wxPyBeginAllowThreads();
29990 result = (wxWindow *)wxWindow::GetCapture();
29991
29992 wxPyEndAllowThreads(__tstate);
29993 if (PyErr_Occurred()) SWIG_fail;
29994 }
29995 {
29996 resultobj = wxPyMake_wxObject(result, 0);
29997 }
29998 return resultobj;
29999 fail:
30000 return NULL;
30001 }
30002
30003
30004 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
30005 PyObject *resultobj = NULL;
30006 wxWindow *arg1 = (wxWindow *) 0 ;
30007 bool result;
30008 PyObject * obj0 = 0 ;
30009 char *kwnames[] = {
30010 (char *) "self", NULL
30011 };
30012
30013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
30014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30015 if (SWIG_arg_fail(1)) SWIG_fail;
30016 {
30017 PyThreadState* __tstate = wxPyBeginAllowThreads();
30018 result = (bool)((wxWindow const *)arg1)->HasCapture();
30019
30020 wxPyEndAllowThreads(__tstate);
30021 if (PyErr_Occurred()) SWIG_fail;
30022 }
30023 {
30024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30025 }
30026 return resultobj;
30027 fail:
30028 return NULL;
30029 }
30030
30031
30032 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
30033 PyObject *resultobj = NULL;
30034 wxWindow *arg1 = (wxWindow *) 0 ;
30035 bool arg2 = (bool) true ;
30036 wxRect *arg3 = (wxRect *) NULL ;
30037 PyObject * obj0 = 0 ;
30038 PyObject * obj1 = 0 ;
30039 PyObject * obj2 = 0 ;
30040 char *kwnames[] = {
30041 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
30042 };
30043
30044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
30045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30046 if (SWIG_arg_fail(1)) SWIG_fail;
30047 if (obj1) {
30048 {
30049 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
30050 if (SWIG_arg_fail(2)) SWIG_fail;
30051 }
30052 }
30053 if (obj2) {
30054 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30055 if (SWIG_arg_fail(3)) SWIG_fail;
30056 }
30057 {
30058 PyThreadState* __tstate = wxPyBeginAllowThreads();
30059 (arg1)->Refresh(arg2,(wxRect const *)arg3);
30060
30061 wxPyEndAllowThreads(__tstate);
30062 if (PyErr_Occurred()) SWIG_fail;
30063 }
30064 Py_INCREF(Py_None); resultobj = Py_None;
30065 return resultobj;
30066 fail:
30067 return NULL;
30068 }
30069
30070
30071 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
30072 PyObject *resultobj = NULL;
30073 wxWindow *arg1 = (wxWindow *) 0 ;
30074 wxRect *arg2 = 0 ;
30075 bool arg3 = (bool) true ;
30076 wxRect temp2 ;
30077 PyObject * obj0 = 0 ;
30078 PyObject * obj1 = 0 ;
30079 PyObject * obj2 = 0 ;
30080 char *kwnames[] = {
30081 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
30082 };
30083
30084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
30085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30086 if (SWIG_arg_fail(1)) SWIG_fail;
30087 {
30088 arg2 = &temp2;
30089 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30090 }
30091 if (obj2) {
30092 {
30093 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
30094 if (SWIG_arg_fail(3)) SWIG_fail;
30095 }
30096 }
30097 {
30098 PyThreadState* __tstate = wxPyBeginAllowThreads();
30099 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
30100
30101 wxPyEndAllowThreads(__tstate);
30102 if (PyErr_Occurred()) SWIG_fail;
30103 }
30104 Py_INCREF(Py_None); resultobj = Py_None;
30105 return resultobj;
30106 fail:
30107 return NULL;
30108 }
30109
30110
30111 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
30112 PyObject *resultobj = NULL;
30113 wxWindow *arg1 = (wxWindow *) 0 ;
30114 PyObject * obj0 = 0 ;
30115 char *kwnames[] = {
30116 (char *) "self", NULL
30117 };
30118
30119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
30120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30121 if (SWIG_arg_fail(1)) SWIG_fail;
30122 {
30123 PyThreadState* __tstate = wxPyBeginAllowThreads();
30124 (arg1)->Update();
30125
30126 wxPyEndAllowThreads(__tstate);
30127 if (PyErr_Occurred()) SWIG_fail;
30128 }
30129 Py_INCREF(Py_None); resultobj = Py_None;
30130 return resultobj;
30131 fail:
30132 return NULL;
30133 }
30134
30135
30136 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30137 PyObject *resultobj = NULL;
30138 wxWindow *arg1 = (wxWindow *) 0 ;
30139 PyObject * obj0 = 0 ;
30140 char *kwnames[] = {
30141 (char *) "self", NULL
30142 };
30143
30144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
30145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30146 if (SWIG_arg_fail(1)) SWIG_fail;
30147 {
30148 PyThreadState* __tstate = wxPyBeginAllowThreads();
30149 (arg1)->ClearBackground();
30150
30151 wxPyEndAllowThreads(__tstate);
30152 if (PyErr_Occurred()) SWIG_fail;
30153 }
30154 Py_INCREF(Py_None); resultobj = Py_None;
30155 return resultobj;
30156 fail:
30157 return NULL;
30158 }
30159
30160
30161 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
30162 PyObject *resultobj = NULL;
30163 wxWindow *arg1 = (wxWindow *) 0 ;
30164 PyObject * obj0 = 0 ;
30165 char *kwnames[] = {
30166 (char *) "self", NULL
30167 };
30168
30169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
30170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30171 if (SWIG_arg_fail(1)) SWIG_fail;
30172 {
30173 PyThreadState* __tstate = wxPyBeginAllowThreads();
30174 (arg1)->Freeze();
30175
30176 wxPyEndAllowThreads(__tstate);
30177 if (PyErr_Occurred()) SWIG_fail;
30178 }
30179 Py_INCREF(Py_None); resultobj = Py_None;
30180 return resultobj;
30181 fail:
30182 return NULL;
30183 }
30184
30185
30186 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
30187 PyObject *resultobj = NULL;
30188 wxWindow *arg1 = (wxWindow *) 0 ;
30189 PyObject * obj0 = 0 ;
30190 char *kwnames[] = {
30191 (char *) "self", NULL
30192 };
30193
30194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
30195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30196 if (SWIG_arg_fail(1)) SWIG_fail;
30197 {
30198 PyThreadState* __tstate = wxPyBeginAllowThreads();
30199 (arg1)->Thaw();
30200
30201 wxPyEndAllowThreads(__tstate);
30202 if (PyErr_Occurred()) SWIG_fail;
30203 }
30204 Py_INCREF(Py_None); resultobj = Py_None;
30205 return resultobj;
30206 fail:
30207 return NULL;
30208 }
30209
30210
30211 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
30212 PyObject *resultobj = NULL;
30213 wxWindow *arg1 = (wxWindow *) 0 ;
30214 wxDC *arg2 = 0 ;
30215 PyObject * obj0 = 0 ;
30216 PyObject * obj1 = 0 ;
30217 char *kwnames[] = {
30218 (char *) "self",(char *) "dc", NULL
30219 };
30220
30221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
30222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30223 if (SWIG_arg_fail(1)) SWIG_fail;
30224 {
30225 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
30226 if (SWIG_arg_fail(2)) SWIG_fail;
30227 if (arg2 == NULL) {
30228 SWIG_null_ref("wxDC");
30229 }
30230 if (SWIG_arg_fail(2)) SWIG_fail;
30231 }
30232 {
30233 PyThreadState* __tstate = wxPyBeginAllowThreads();
30234 (arg1)->PrepareDC(*arg2);
30235
30236 wxPyEndAllowThreads(__tstate);
30237 if (PyErr_Occurred()) SWIG_fail;
30238 }
30239 Py_INCREF(Py_None); resultobj = Py_None;
30240 return resultobj;
30241 fail:
30242 return NULL;
30243 }
30244
30245
30246 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
30247 PyObject *resultobj = NULL;
30248 wxWindow *arg1 = (wxWindow *) 0 ;
30249 wxRegion *result;
30250 PyObject * obj0 = 0 ;
30251 char *kwnames[] = {
30252 (char *) "self", NULL
30253 };
30254
30255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
30256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30257 if (SWIG_arg_fail(1)) SWIG_fail;
30258 {
30259 PyThreadState* __tstate = wxPyBeginAllowThreads();
30260 {
30261 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
30262 result = (wxRegion *) &_result_ref;
30263 }
30264
30265 wxPyEndAllowThreads(__tstate);
30266 if (PyErr_Occurred()) SWIG_fail;
30267 }
30268 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
30269 return resultobj;
30270 fail:
30271 return NULL;
30272 }
30273
30274
30275 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
30276 PyObject *resultobj = NULL;
30277 wxWindow *arg1 = (wxWindow *) 0 ;
30278 wxRect result;
30279 PyObject * obj0 = 0 ;
30280 char *kwnames[] = {
30281 (char *) "self", NULL
30282 };
30283
30284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
30285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30286 if (SWIG_arg_fail(1)) SWIG_fail;
30287 {
30288 PyThreadState* __tstate = wxPyBeginAllowThreads();
30289 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
30290
30291 wxPyEndAllowThreads(__tstate);
30292 if (PyErr_Occurred()) SWIG_fail;
30293 }
30294 {
30295 wxRect * resultptr;
30296 resultptr = new wxRect(static_cast<wxRect & >(result));
30297 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30298 }
30299 return resultobj;
30300 fail:
30301 return NULL;
30302 }
30303
30304
30305 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
30306 PyObject *resultobj = NULL;
30307 wxWindow *arg1 = (wxWindow *) 0 ;
30308 int arg2 ;
30309 int arg3 ;
30310 int arg4 = (int) 1 ;
30311 int arg5 = (int) 1 ;
30312 bool result;
30313 PyObject * obj0 = 0 ;
30314 PyObject * obj1 = 0 ;
30315 PyObject * obj2 = 0 ;
30316 PyObject * obj3 = 0 ;
30317 PyObject * obj4 = 0 ;
30318 char *kwnames[] = {
30319 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
30320 };
30321
30322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
30323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30324 if (SWIG_arg_fail(1)) SWIG_fail;
30325 {
30326 arg2 = static_cast<int >(SWIG_As_int(obj1));
30327 if (SWIG_arg_fail(2)) SWIG_fail;
30328 }
30329 {
30330 arg3 = static_cast<int >(SWIG_As_int(obj2));
30331 if (SWIG_arg_fail(3)) SWIG_fail;
30332 }
30333 if (obj3) {
30334 {
30335 arg4 = static_cast<int >(SWIG_As_int(obj3));
30336 if (SWIG_arg_fail(4)) SWIG_fail;
30337 }
30338 }
30339 if (obj4) {
30340 {
30341 arg5 = static_cast<int >(SWIG_As_int(obj4));
30342 if (SWIG_arg_fail(5)) SWIG_fail;
30343 }
30344 }
30345 {
30346 PyThreadState* __tstate = wxPyBeginAllowThreads();
30347 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
30348
30349 wxPyEndAllowThreads(__tstate);
30350 if (PyErr_Occurred()) SWIG_fail;
30351 }
30352 {
30353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30354 }
30355 return resultobj;
30356 fail:
30357 return NULL;
30358 }
30359
30360
30361 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30362 PyObject *resultobj = NULL;
30363 wxWindow *arg1 = (wxWindow *) 0 ;
30364 wxPoint *arg2 = 0 ;
30365 bool result;
30366 wxPoint temp2 ;
30367 PyObject * obj0 = 0 ;
30368 PyObject * obj1 = 0 ;
30369 char *kwnames[] = {
30370 (char *) "self",(char *) "pt", NULL
30371 };
30372
30373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
30374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30375 if (SWIG_arg_fail(1)) SWIG_fail;
30376 {
30377 arg2 = &temp2;
30378 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30379 }
30380 {
30381 PyThreadState* __tstate = wxPyBeginAllowThreads();
30382 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
30383
30384 wxPyEndAllowThreads(__tstate);
30385 if (PyErr_Occurred()) SWIG_fail;
30386 }
30387 {
30388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30389 }
30390 return resultobj;
30391 fail:
30392 return NULL;
30393 }
30394
30395
30396 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
30397 PyObject *resultobj = NULL;
30398 wxWindow *arg1 = (wxWindow *) 0 ;
30399 wxRect *arg2 = 0 ;
30400 bool result;
30401 wxRect temp2 ;
30402 PyObject * obj0 = 0 ;
30403 PyObject * obj1 = 0 ;
30404 char *kwnames[] = {
30405 (char *) "self",(char *) "rect", NULL
30406 };
30407
30408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
30409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30410 if (SWIG_arg_fail(1)) SWIG_fail;
30411 {
30412 arg2 = &temp2;
30413 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30414 }
30415 {
30416 PyThreadState* __tstate = wxPyBeginAllowThreads();
30417 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
30418
30419 wxPyEndAllowThreads(__tstate);
30420 if (PyErr_Occurred()) SWIG_fail;
30421 }
30422 {
30423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30424 }
30425 return resultobj;
30426 fail:
30427 return NULL;
30428 }
30429
30430
30431 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30432 PyObject *resultobj = NULL;
30433 wxWindow *arg1 = (wxWindow *) 0 ;
30434 wxVisualAttributes result;
30435 PyObject * obj0 = 0 ;
30436 char *kwnames[] = {
30437 (char *) "self", NULL
30438 };
30439
30440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
30441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30442 if (SWIG_arg_fail(1)) SWIG_fail;
30443 {
30444 PyThreadState* __tstate = wxPyBeginAllowThreads();
30445 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
30446
30447 wxPyEndAllowThreads(__tstate);
30448 if (PyErr_Occurred()) SWIG_fail;
30449 }
30450 {
30451 wxVisualAttributes * resultptr;
30452 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
30453 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30454 }
30455 return resultobj;
30456 fail:
30457 return NULL;
30458 }
30459
30460
30461 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30462 PyObject *resultobj = NULL;
30463 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
30464 wxVisualAttributes result;
30465 PyObject * obj0 = 0 ;
30466 char *kwnames[] = {
30467 (char *) "variant", NULL
30468 };
30469
30470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
30471 if (obj0) {
30472 {
30473 arg1 = static_cast<wxWindowVariant >(SWIG_As_int(obj0));
30474 if (SWIG_arg_fail(1)) SWIG_fail;
30475 }
30476 }
30477 {
30478 if (!wxPyCheckForApp()) SWIG_fail;
30479 PyThreadState* __tstate = wxPyBeginAllowThreads();
30480 result = wxWindow::GetClassDefaultAttributes(arg1);
30481
30482 wxPyEndAllowThreads(__tstate);
30483 if (PyErr_Occurred()) SWIG_fail;
30484 }
30485 {
30486 wxVisualAttributes * resultptr;
30487 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
30488 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30489 }
30490 return resultobj;
30491 fail:
30492 return NULL;
30493 }
30494
30495
30496 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30497 PyObject *resultobj = NULL;
30498 wxWindow *arg1 = (wxWindow *) 0 ;
30499 wxColour *arg2 = 0 ;
30500 bool result;
30501 wxColour temp2 ;
30502 PyObject * obj0 = 0 ;
30503 PyObject * obj1 = 0 ;
30504 char *kwnames[] = {
30505 (char *) "self",(char *) "colour", NULL
30506 };
30507
30508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30510 if (SWIG_arg_fail(1)) SWIG_fail;
30511 {
30512 arg2 = &temp2;
30513 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30514 }
30515 {
30516 PyThreadState* __tstate = wxPyBeginAllowThreads();
30517 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
30518
30519 wxPyEndAllowThreads(__tstate);
30520 if (PyErr_Occurred()) SWIG_fail;
30521 }
30522 {
30523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30524 }
30525 return resultobj;
30526 fail:
30527 return NULL;
30528 }
30529
30530
30531 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30532 PyObject *resultobj = NULL;
30533 wxWindow *arg1 = (wxWindow *) 0 ;
30534 wxColour *arg2 = 0 ;
30535 wxColour temp2 ;
30536 PyObject * obj0 = 0 ;
30537 PyObject * obj1 = 0 ;
30538 char *kwnames[] = {
30539 (char *) "self",(char *) "colour", NULL
30540 };
30541
30542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30544 if (SWIG_arg_fail(1)) SWIG_fail;
30545 {
30546 arg2 = &temp2;
30547 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30548 }
30549 {
30550 PyThreadState* __tstate = wxPyBeginAllowThreads();
30551 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
30552
30553 wxPyEndAllowThreads(__tstate);
30554 if (PyErr_Occurred()) SWIG_fail;
30555 }
30556 Py_INCREF(Py_None); resultobj = Py_None;
30557 return resultobj;
30558 fail:
30559 return NULL;
30560 }
30561
30562
30563 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30564 PyObject *resultobj = NULL;
30565 wxWindow *arg1 = (wxWindow *) 0 ;
30566 wxColour *arg2 = 0 ;
30567 bool result;
30568 wxColour temp2 ;
30569 PyObject * obj0 = 0 ;
30570 PyObject * obj1 = 0 ;
30571 char *kwnames[] = {
30572 (char *) "self",(char *) "colour", NULL
30573 };
30574
30575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30577 if (SWIG_arg_fail(1)) SWIG_fail;
30578 {
30579 arg2 = &temp2;
30580 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30581 }
30582 {
30583 PyThreadState* __tstate = wxPyBeginAllowThreads();
30584 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
30585
30586 wxPyEndAllowThreads(__tstate);
30587 if (PyErr_Occurred()) SWIG_fail;
30588 }
30589 {
30590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30591 }
30592 return resultobj;
30593 fail:
30594 return NULL;
30595 }
30596
30597
30598 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30599 PyObject *resultobj = NULL;
30600 wxWindow *arg1 = (wxWindow *) 0 ;
30601 wxColour *arg2 = 0 ;
30602 wxColour temp2 ;
30603 PyObject * obj0 = 0 ;
30604 PyObject * obj1 = 0 ;
30605 char *kwnames[] = {
30606 (char *) "self",(char *) "colour", NULL
30607 };
30608
30609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30611 if (SWIG_arg_fail(1)) SWIG_fail;
30612 {
30613 arg2 = &temp2;
30614 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30615 }
30616 {
30617 PyThreadState* __tstate = wxPyBeginAllowThreads();
30618 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
30619
30620 wxPyEndAllowThreads(__tstate);
30621 if (PyErr_Occurred()) SWIG_fail;
30622 }
30623 Py_INCREF(Py_None); resultobj = Py_None;
30624 return resultobj;
30625 fail:
30626 return NULL;
30627 }
30628
30629
30630 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30631 PyObject *resultobj = NULL;
30632 wxWindow *arg1 = (wxWindow *) 0 ;
30633 wxColour result;
30634 PyObject * obj0 = 0 ;
30635 char *kwnames[] = {
30636 (char *) "self", NULL
30637 };
30638
30639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
30640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30641 if (SWIG_arg_fail(1)) SWIG_fail;
30642 {
30643 PyThreadState* __tstate = wxPyBeginAllowThreads();
30644 result = ((wxWindow const *)arg1)->GetBackgroundColour();
30645
30646 wxPyEndAllowThreads(__tstate);
30647 if (PyErr_Occurred()) SWIG_fail;
30648 }
30649 {
30650 wxColour * resultptr;
30651 resultptr = new wxColour(static_cast<wxColour & >(result));
30652 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30653 }
30654 return resultobj;
30655 fail:
30656 return NULL;
30657 }
30658
30659
30660 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30661 PyObject *resultobj = NULL;
30662 wxWindow *arg1 = (wxWindow *) 0 ;
30663 wxColour result;
30664 PyObject * obj0 = 0 ;
30665 char *kwnames[] = {
30666 (char *) "self", NULL
30667 };
30668
30669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
30670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30671 if (SWIG_arg_fail(1)) SWIG_fail;
30672 {
30673 PyThreadState* __tstate = wxPyBeginAllowThreads();
30674 result = ((wxWindow const *)arg1)->GetForegroundColour();
30675
30676 wxPyEndAllowThreads(__tstate);
30677 if (PyErr_Occurred()) SWIG_fail;
30678 }
30679 {
30680 wxColour * resultptr;
30681 resultptr = new wxColour(static_cast<wxColour & >(result));
30682 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30683 }
30684 return resultobj;
30685 fail:
30686 return NULL;
30687 }
30688
30689
30690 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30691 PyObject *resultobj = NULL;
30692 wxWindow *arg1 = (wxWindow *) 0 ;
30693 bool result;
30694 PyObject * obj0 = 0 ;
30695 char *kwnames[] = {
30696 (char *) "self", NULL
30697 };
30698
30699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
30700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30701 if (SWIG_arg_fail(1)) SWIG_fail;
30702 {
30703 PyThreadState* __tstate = wxPyBeginAllowThreads();
30704 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
30705
30706 wxPyEndAllowThreads(__tstate);
30707 if (PyErr_Occurred()) SWIG_fail;
30708 }
30709 {
30710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30711 }
30712 return resultobj;
30713 fail:
30714 return NULL;
30715 }
30716
30717
30718 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
30719 PyObject *resultobj = NULL;
30720 wxWindow *arg1 = (wxWindow *) 0 ;
30721 bool result;
30722 PyObject * obj0 = 0 ;
30723 char *kwnames[] = {
30724 (char *) "self", NULL
30725 };
30726
30727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
30728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30729 if (SWIG_arg_fail(1)) SWIG_fail;
30730 {
30731 PyThreadState* __tstate = wxPyBeginAllowThreads();
30732 result = (bool)((wxWindow const *)arg1)->UseBgCol();
30733
30734 wxPyEndAllowThreads(__tstate);
30735 if (PyErr_Occurred()) SWIG_fail;
30736 }
30737 {
30738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30739 }
30740 return resultobj;
30741 fail:
30742 return NULL;
30743 }
30744
30745
30746 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30747 PyObject *resultobj = NULL;
30748 wxWindow *arg1 = (wxWindow *) 0 ;
30749 wxBackgroundStyle arg2 ;
30750 bool result;
30751 PyObject * obj0 = 0 ;
30752 PyObject * obj1 = 0 ;
30753 char *kwnames[] = {
30754 (char *) "self",(char *) "style", NULL
30755 };
30756
30757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
30758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30759 if (SWIG_arg_fail(1)) SWIG_fail;
30760 {
30761 arg2 = static_cast<wxBackgroundStyle >(SWIG_As_int(obj1));
30762 if (SWIG_arg_fail(2)) SWIG_fail;
30763 }
30764 {
30765 PyThreadState* __tstate = wxPyBeginAllowThreads();
30766 result = (bool)(arg1)->SetBackgroundStyle(arg2);
30767
30768 wxPyEndAllowThreads(__tstate);
30769 if (PyErr_Occurred()) SWIG_fail;
30770 }
30771 {
30772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30773 }
30774 return resultobj;
30775 fail:
30776 return NULL;
30777 }
30778
30779
30780 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30781 PyObject *resultobj = NULL;
30782 wxWindow *arg1 = (wxWindow *) 0 ;
30783 wxBackgroundStyle result;
30784 PyObject * obj0 = 0 ;
30785 char *kwnames[] = {
30786 (char *) "self", NULL
30787 };
30788
30789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
30790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30791 if (SWIG_arg_fail(1)) SWIG_fail;
30792 {
30793 PyThreadState* __tstate = wxPyBeginAllowThreads();
30794 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30795
30796 wxPyEndAllowThreads(__tstate);
30797 if (PyErr_Occurred()) SWIG_fail;
30798 }
30799 resultobj = SWIG_From_int((result));
30800 return resultobj;
30801 fail:
30802 return NULL;
30803 }
30804
30805
30806 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30807 PyObject *resultobj = NULL;
30808 wxWindow *arg1 = (wxWindow *) 0 ;
30809 bool result;
30810 PyObject * obj0 = 0 ;
30811 char *kwnames[] = {
30812 (char *) "self", NULL
30813 };
30814
30815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30817 if (SWIG_arg_fail(1)) SWIG_fail;
30818 {
30819 PyThreadState* __tstate = wxPyBeginAllowThreads();
30820 result = (bool)(arg1)->HasTransparentBackground();
30821
30822 wxPyEndAllowThreads(__tstate);
30823 if (PyErr_Occurred()) SWIG_fail;
30824 }
30825 {
30826 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30827 }
30828 return resultobj;
30829 fail:
30830 return NULL;
30831 }
30832
30833
30834 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30835 PyObject *resultobj = NULL;
30836 wxWindow *arg1 = (wxWindow *) 0 ;
30837 wxCursor *arg2 = 0 ;
30838 bool result;
30839 PyObject * obj0 = 0 ;
30840 PyObject * obj1 = 0 ;
30841 char *kwnames[] = {
30842 (char *) "self",(char *) "cursor", NULL
30843 };
30844
30845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30847 if (SWIG_arg_fail(1)) SWIG_fail;
30848 {
30849 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30850 if (SWIG_arg_fail(2)) SWIG_fail;
30851 if (arg2 == NULL) {
30852 SWIG_null_ref("wxCursor");
30853 }
30854 if (SWIG_arg_fail(2)) SWIG_fail;
30855 }
30856 {
30857 PyThreadState* __tstate = wxPyBeginAllowThreads();
30858 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30859
30860 wxPyEndAllowThreads(__tstate);
30861 if (PyErr_Occurred()) SWIG_fail;
30862 }
30863 {
30864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30865 }
30866 return resultobj;
30867 fail:
30868 return NULL;
30869 }
30870
30871
30872 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30873 PyObject *resultobj = NULL;
30874 wxWindow *arg1 = (wxWindow *) 0 ;
30875 wxCursor result;
30876 PyObject * obj0 = 0 ;
30877 char *kwnames[] = {
30878 (char *) "self", NULL
30879 };
30880
30881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30883 if (SWIG_arg_fail(1)) SWIG_fail;
30884 {
30885 PyThreadState* __tstate = wxPyBeginAllowThreads();
30886 result = (arg1)->GetCursor();
30887
30888 wxPyEndAllowThreads(__tstate);
30889 if (PyErr_Occurred()) SWIG_fail;
30890 }
30891 {
30892 wxCursor * resultptr;
30893 resultptr = new wxCursor(static_cast<wxCursor & >(result));
30894 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30895 }
30896 return resultobj;
30897 fail:
30898 return NULL;
30899 }
30900
30901
30902 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30903 PyObject *resultobj = NULL;
30904 wxWindow *arg1 = (wxWindow *) 0 ;
30905 wxFont *arg2 = 0 ;
30906 bool result;
30907 PyObject * obj0 = 0 ;
30908 PyObject * obj1 = 0 ;
30909 char *kwnames[] = {
30910 (char *) "self",(char *) "font", NULL
30911 };
30912
30913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30915 if (SWIG_arg_fail(1)) SWIG_fail;
30916 {
30917 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30918 if (SWIG_arg_fail(2)) SWIG_fail;
30919 if (arg2 == NULL) {
30920 SWIG_null_ref("wxFont");
30921 }
30922 if (SWIG_arg_fail(2)) SWIG_fail;
30923 }
30924 {
30925 PyThreadState* __tstate = wxPyBeginAllowThreads();
30926 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30927
30928 wxPyEndAllowThreads(__tstate);
30929 if (PyErr_Occurred()) SWIG_fail;
30930 }
30931 {
30932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30933 }
30934 return resultobj;
30935 fail:
30936 return NULL;
30937 }
30938
30939
30940 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30941 PyObject *resultobj = NULL;
30942 wxWindow *arg1 = (wxWindow *) 0 ;
30943 wxFont *arg2 = 0 ;
30944 PyObject * obj0 = 0 ;
30945 PyObject * obj1 = 0 ;
30946 char *kwnames[] = {
30947 (char *) "self",(char *) "font", NULL
30948 };
30949
30950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30952 if (SWIG_arg_fail(1)) SWIG_fail;
30953 {
30954 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30955 if (SWIG_arg_fail(2)) SWIG_fail;
30956 if (arg2 == NULL) {
30957 SWIG_null_ref("wxFont");
30958 }
30959 if (SWIG_arg_fail(2)) SWIG_fail;
30960 }
30961 {
30962 PyThreadState* __tstate = wxPyBeginAllowThreads();
30963 (arg1)->SetOwnFont((wxFont const &)*arg2);
30964
30965 wxPyEndAllowThreads(__tstate);
30966 if (PyErr_Occurred()) SWIG_fail;
30967 }
30968 Py_INCREF(Py_None); resultobj = Py_None;
30969 return resultobj;
30970 fail:
30971 return NULL;
30972 }
30973
30974
30975 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30976 PyObject *resultobj = NULL;
30977 wxWindow *arg1 = (wxWindow *) 0 ;
30978 wxFont result;
30979 PyObject * obj0 = 0 ;
30980 char *kwnames[] = {
30981 (char *) "self", NULL
30982 };
30983
30984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30986 if (SWIG_arg_fail(1)) SWIG_fail;
30987 {
30988 PyThreadState* __tstate = wxPyBeginAllowThreads();
30989 result = (arg1)->GetFont();
30990
30991 wxPyEndAllowThreads(__tstate);
30992 if (PyErr_Occurred()) SWIG_fail;
30993 }
30994 {
30995 wxFont * resultptr;
30996 resultptr = new wxFont(static_cast<wxFont & >(result));
30997 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30998 }
30999 return resultobj;
31000 fail:
31001 return NULL;
31002 }
31003
31004
31005 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
31006 PyObject *resultobj = NULL;
31007 wxWindow *arg1 = (wxWindow *) 0 ;
31008 wxCaret *arg2 = (wxCaret *) 0 ;
31009 PyObject * obj0 = 0 ;
31010 PyObject * obj1 = 0 ;
31011 char *kwnames[] = {
31012 (char *) "self",(char *) "caret", NULL
31013 };
31014
31015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
31016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31017 if (SWIG_arg_fail(1)) SWIG_fail;
31018 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31019 if (SWIG_arg_fail(2)) SWIG_fail;
31020 {
31021 PyThreadState* __tstate = wxPyBeginAllowThreads();
31022 (arg1)->SetCaret(arg2);
31023
31024 wxPyEndAllowThreads(__tstate);
31025 if (PyErr_Occurred()) SWIG_fail;
31026 }
31027 Py_INCREF(Py_None); resultobj = Py_None;
31028 return resultobj;
31029 fail:
31030 return NULL;
31031 }
31032
31033
31034 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
31035 PyObject *resultobj = NULL;
31036 wxWindow *arg1 = (wxWindow *) 0 ;
31037 wxCaret *result;
31038 PyObject * obj0 = 0 ;
31039 char *kwnames[] = {
31040 (char *) "self", NULL
31041 };
31042
31043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
31044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31045 if (SWIG_arg_fail(1)) SWIG_fail;
31046 {
31047 PyThreadState* __tstate = wxPyBeginAllowThreads();
31048 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
31049
31050 wxPyEndAllowThreads(__tstate);
31051 if (PyErr_Occurred()) SWIG_fail;
31052 }
31053 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
31054 return resultobj;
31055 fail:
31056 return NULL;
31057 }
31058
31059
31060 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
31061 PyObject *resultobj = NULL;
31062 wxWindow *arg1 = (wxWindow *) 0 ;
31063 int result;
31064 PyObject * obj0 = 0 ;
31065 char *kwnames[] = {
31066 (char *) "self", NULL
31067 };
31068
31069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
31070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31071 if (SWIG_arg_fail(1)) SWIG_fail;
31072 {
31073 PyThreadState* __tstate = wxPyBeginAllowThreads();
31074 result = (int)((wxWindow const *)arg1)->GetCharHeight();
31075
31076 wxPyEndAllowThreads(__tstate);
31077 if (PyErr_Occurred()) SWIG_fail;
31078 }
31079 {
31080 resultobj = SWIG_From_int(static_cast<int >(result));
31081 }
31082 return resultobj;
31083 fail:
31084 return NULL;
31085 }
31086
31087
31088 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
31089 PyObject *resultobj = NULL;
31090 wxWindow *arg1 = (wxWindow *) 0 ;
31091 int result;
31092 PyObject * obj0 = 0 ;
31093 char *kwnames[] = {
31094 (char *) "self", NULL
31095 };
31096
31097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
31098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31099 if (SWIG_arg_fail(1)) SWIG_fail;
31100 {
31101 PyThreadState* __tstate = wxPyBeginAllowThreads();
31102 result = (int)((wxWindow const *)arg1)->GetCharWidth();
31103
31104 wxPyEndAllowThreads(__tstate);
31105 if (PyErr_Occurred()) SWIG_fail;
31106 }
31107 {
31108 resultobj = SWIG_From_int(static_cast<int >(result));
31109 }
31110 return resultobj;
31111 fail:
31112 return NULL;
31113 }
31114
31115
31116 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
31117 PyObject *resultobj = NULL;
31118 wxWindow *arg1 = (wxWindow *) 0 ;
31119 wxString *arg2 = 0 ;
31120 int *arg3 = (int *) 0 ;
31121 int *arg4 = (int *) 0 ;
31122 bool temp2 = false ;
31123 int temp3 ;
31124 int res3 = 0 ;
31125 int temp4 ;
31126 int res4 = 0 ;
31127 PyObject * obj0 = 0 ;
31128 PyObject * obj1 = 0 ;
31129 char *kwnames[] = {
31130 (char *) "self",(char *) "string", NULL
31131 };
31132
31133 arg3 = &temp3; res3 = SWIG_NEWOBJ;
31134 arg4 = &temp4; res4 = SWIG_NEWOBJ;
31135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
31136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31137 if (SWIG_arg_fail(1)) SWIG_fail;
31138 {
31139 arg2 = wxString_in_helper(obj1);
31140 if (arg2 == NULL) SWIG_fail;
31141 temp2 = true;
31142 }
31143 {
31144 PyThreadState* __tstate = wxPyBeginAllowThreads();
31145 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
31146
31147 wxPyEndAllowThreads(__tstate);
31148 if (PyErr_Occurred()) SWIG_fail;
31149 }
31150 Py_INCREF(Py_None); resultobj = Py_None;
31151 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31152 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31153 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
31154 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
31155 {
31156 if (temp2)
31157 delete arg2;
31158 }
31159 return resultobj;
31160 fail:
31161 {
31162 if (temp2)
31163 delete arg2;
31164 }
31165 return NULL;
31166 }
31167
31168
31169 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
31170 PyObject *resultobj = NULL;
31171 wxWindow *arg1 = (wxWindow *) 0 ;
31172 wxString *arg2 = 0 ;
31173 int *arg3 = (int *) 0 ;
31174 int *arg4 = (int *) 0 ;
31175 int *arg5 = (int *) 0 ;
31176 int *arg6 = (int *) 0 ;
31177 wxFont *arg7 = (wxFont *) NULL ;
31178 bool temp2 = false ;
31179 int temp3 ;
31180 int res3 = 0 ;
31181 int temp4 ;
31182 int res4 = 0 ;
31183 int temp5 ;
31184 int res5 = 0 ;
31185 int temp6 ;
31186 int res6 = 0 ;
31187 PyObject * obj0 = 0 ;
31188 PyObject * obj1 = 0 ;
31189 PyObject * obj2 = 0 ;
31190 char *kwnames[] = {
31191 (char *) "self",(char *) "string",(char *) "font", NULL
31192 };
31193
31194 arg3 = &temp3; res3 = SWIG_NEWOBJ;
31195 arg4 = &temp4; res4 = SWIG_NEWOBJ;
31196 arg5 = &temp5; res5 = SWIG_NEWOBJ;
31197 arg6 = &temp6; res6 = SWIG_NEWOBJ;
31198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
31199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31200 if (SWIG_arg_fail(1)) SWIG_fail;
31201 {
31202 arg2 = wxString_in_helper(obj1);
31203 if (arg2 == NULL) SWIG_fail;
31204 temp2 = true;
31205 }
31206 if (obj2) {
31207 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
31208 if (SWIG_arg_fail(7)) SWIG_fail;
31209 }
31210 {
31211 PyThreadState* __tstate = wxPyBeginAllowThreads();
31212 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
31213
31214 wxPyEndAllowThreads(__tstate);
31215 if (PyErr_Occurred()) SWIG_fail;
31216 }
31217 Py_INCREF(Py_None); resultobj = Py_None;
31218 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31219 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31220 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
31221 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
31222 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
31223 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
31224 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
31225 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
31226 {
31227 if (temp2)
31228 delete arg2;
31229 }
31230 return resultobj;
31231 fail:
31232 {
31233 if (temp2)
31234 delete arg2;
31235 }
31236 return NULL;
31237 }
31238
31239
31240 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
31241 PyObject *resultobj = NULL;
31242 wxWindow *arg1 = (wxWindow *) 0 ;
31243 int *arg2 = (int *) 0 ;
31244 int *arg3 = (int *) 0 ;
31245 int temp2 ;
31246 int res2 = 0 ;
31247 int temp3 ;
31248 int res3 = 0 ;
31249 PyObject * obj0 = 0 ;
31250 PyObject * obj1 = 0 ;
31251 PyObject * obj2 = 0 ;
31252 char *kwnames[] = {
31253 (char *) "self",(char *) "x",(char *) "y", NULL
31254 };
31255
31256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31258 if (SWIG_arg_fail(1)) SWIG_fail;
31259 {
31260 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31261 temp2 = SWIG_As_int(obj1);
31262 if (SWIG_arg_fail(2)) SWIG_fail;
31263 arg2 = &temp2;
31264 res2 = SWIG_NEWOBJ;
31265 }
31266 }
31267 {
31268 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31269 temp3 = SWIG_As_int(obj2);
31270 if (SWIG_arg_fail(3)) SWIG_fail;
31271 arg3 = &temp3;
31272 res3 = SWIG_NEWOBJ;
31273 }
31274 }
31275 {
31276 PyThreadState* __tstate = wxPyBeginAllowThreads();
31277 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
31278
31279 wxPyEndAllowThreads(__tstate);
31280 if (PyErr_Occurred()) SWIG_fail;
31281 }
31282 Py_INCREF(Py_None); resultobj = Py_None;
31283 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31284 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31285 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31286 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31287 return resultobj;
31288 fail:
31289 return NULL;
31290 }
31291
31292
31293 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
31294 PyObject *resultobj = NULL;
31295 wxWindow *arg1 = (wxWindow *) 0 ;
31296 int *arg2 = (int *) 0 ;
31297 int *arg3 = (int *) 0 ;
31298 int temp2 ;
31299 int res2 = 0 ;
31300 int temp3 ;
31301 int res3 = 0 ;
31302 PyObject * obj0 = 0 ;
31303 PyObject * obj1 = 0 ;
31304 PyObject * obj2 = 0 ;
31305 char *kwnames[] = {
31306 (char *) "self",(char *) "x",(char *) "y", NULL
31307 };
31308
31309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31311 if (SWIG_arg_fail(1)) SWIG_fail;
31312 {
31313 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31314 temp2 = SWIG_As_int(obj1);
31315 if (SWIG_arg_fail(2)) SWIG_fail;
31316 arg2 = &temp2;
31317 res2 = SWIG_NEWOBJ;
31318 }
31319 }
31320 {
31321 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31322 temp3 = SWIG_As_int(obj2);
31323 if (SWIG_arg_fail(3)) SWIG_fail;
31324 arg3 = &temp3;
31325 res3 = SWIG_NEWOBJ;
31326 }
31327 }
31328 {
31329 PyThreadState* __tstate = wxPyBeginAllowThreads();
31330 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
31331
31332 wxPyEndAllowThreads(__tstate);
31333 if (PyErr_Occurred()) SWIG_fail;
31334 }
31335 Py_INCREF(Py_None); resultobj = Py_None;
31336 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31337 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31338 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31339 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31340 return resultobj;
31341 fail:
31342 return NULL;
31343 }
31344
31345
31346 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
31347 PyObject *resultobj = NULL;
31348 wxWindow *arg1 = (wxWindow *) 0 ;
31349 wxPoint *arg2 = 0 ;
31350 wxPoint result;
31351 wxPoint temp2 ;
31352 PyObject * obj0 = 0 ;
31353 PyObject * obj1 = 0 ;
31354 char *kwnames[] = {
31355 (char *) "self",(char *) "pt", NULL
31356 };
31357
31358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
31359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31360 if (SWIG_arg_fail(1)) SWIG_fail;
31361 {
31362 arg2 = &temp2;
31363 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31364 }
31365 {
31366 PyThreadState* __tstate = wxPyBeginAllowThreads();
31367 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
31368
31369 wxPyEndAllowThreads(__tstate);
31370 if (PyErr_Occurred()) SWIG_fail;
31371 }
31372 {
31373 wxPoint * resultptr;
31374 resultptr = new wxPoint(static_cast<wxPoint & >(result));
31375 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31376 }
31377 return resultobj;
31378 fail:
31379 return NULL;
31380 }
31381
31382
31383 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
31384 PyObject *resultobj = NULL;
31385 wxWindow *arg1 = (wxWindow *) 0 ;
31386 wxPoint *arg2 = 0 ;
31387 wxPoint result;
31388 wxPoint temp2 ;
31389 PyObject * obj0 = 0 ;
31390 PyObject * obj1 = 0 ;
31391 char *kwnames[] = {
31392 (char *) "self",(char *) "pt", NULL
31393 };
31394
31395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
31396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31397 if (SWIG_arg_fail(1)) SWIG_fail;
31398 {
31399 arg2 = &temp2;
31400 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31401 }
31402 {
31403 PyThreadState* __tstate = wxPyBeginAllowThreads();
31404 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
31405
31406 wxPyEndAllowThreads(__tstate);
31407 if (PyErr_Occurred()) SWIG_fail;
31408 }
31409 {
31410 wxPoint * resultptr;
31411 resultptr = new wxPoint(static_cast<wxPoint & >(result));
31412 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31413 }
31414 return resultobj;
31415 fail:
31416 return NULL;
31417 }
31418
31419
31420 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
31421 PyObject *resultobj = NULL;
31422 wxWindow *arg1 = (wxWindow *) 0 ;
31423 int arg2 ;
31424 int arg3 ;
31425 wxHitTest result;
31426 PyObject * obj0 = 0 ;
31427 PyObject * obj1 = 0 ;
31428 PyObject * obj2 = 0 ;
31429 char *kwnames[] = {
31430 (char *) "self",(char *) "x",(char *) "y", NULL
31431 };
31432
31433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31435 if (SWIG_arg_fail(1)) SWIG_fail;
31436 {
31437 arg2 = static_cast<int >(SWIG_As_int(obj1));
31438 if (SWIG_arg_fail(2)) SWIG_fail;
31439 }
31440 {
31441 arg3 = static_cast<int >(SWIG_As_int(obj2));
31442 if (SWIG_arg_fail(3)) SWIG_fail;
31443 }
31444 {
31445 PyThreadState* __tstate = wxPyBeginAllowThreads();
31446 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
31447
31448 wxPyEndAllowThreads(__tstate);
31449 if (PyErr_Occurred()) SWIG_fail;
31450 }
31451 resultobj = SWIG_From_int((result));
31452 return resultobj;
31453 fail:
31454 return NULL;
31455 }
31456
31457
31458 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
31459 PyObject *resultobj = NULL;
31460 wxWindow *arg1 = (wxWindow *) 0 ;
31461 wxPoint *arg2 = 0 ;
31462 wxHitTest result;
31463 wxPoint temp2 ;
31464 PyObject * obj0 = 0 ;
31465 PyObject * obj1 = 0 ;
31466 char *kwnames[] = {
31467 (char *) "self",(char *) "pt", NULL
31468 };
31469
31470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
31471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31472 if (SWIG_arg_fail(1)) SWIG_fail;
31473 {
31474 arg2 = &temp2;
31475 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31476 }
31477 {
31478 PyThreadState* __tstate = wxPyBeginAllowThreads();
31479 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
31480
31481 wxPyEndAllowThreads(__tstate);
31482 if (PyErr_Occurred()) SWIG_fail;
31483 }
31484 resultobj = SWIG_From_int((result));
31485 return resultobj;
31486 fail:
31487 return NULL;
31488 }
31489
31490
31491 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
31492 PyObject *resultobj = NULL;
31493 wxWindow *arg1 = (wxWindow *) 0 ;
31494 long arg2 ;
31495 wxBorder result;
31496 PyObject * obj0 = 0 ;
31497 PyObject * obj1 = 0 ;
31498
31499 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
31500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31501 if (SWIG_arg_fail(1)) SWIG_fail;
31502 {
31503 arg2 = static_cast<long >(SWIG_As_long(obj1));
31504 if (SWIG_arg_fail(2)) SWIG_fail;
31505 }
31506 {
31507 PyThreadState* __tstate = wxPyBeginAllowThreads();
31508 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
31509
31510 wxPyEndAllowThreads(__tstate);
31511 if (PyErr_Occurred()) SWIG_fail;
31512 }
31513 resultobj = SWIG_From_int((result));
31514 return resultobj;
31515 fail:
31516 return NULL;
31517 }
31518
31519
31520 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
31521 PyObject *resultobj = NULL;
31522 wxWindow *arg1 = (wxWindow *) 0 ;
31523 wxBorder result;
31524 PyObject * obj0 = 0 ;
31525
31526 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
31527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31528 if (SWIG_arg_fail(1)) SWIG_fail;
31529 {
31530 PyThreadState* __tstate = wxPyBeginAllowThreads();
31531 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
31532
31533 wxPyEndAllowThreads(__tstate);
31534 if (PyErr_Occurred()) SWIG_fail;
31535 }
31536 resultobj = SWIG_From_int((result));
31537 return resultobj;
31538 fail:
31539 return NULL;
31540 }
31541
31542
31543 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
31544 int argc;
31545 PyObject *argv[3];
31546 int ii;
31547
31548 argc = PyObject_Length(args);
31549 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
31550 argv[ii] = PyTuple_GetItem(args,ii);
31551 }
31552 if (argc == 1) {
31553 int _v;
31554 {
31555 void *ptr;
31556 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31557 _v = 0;
31558 PyErr_Clear();
31559 } else {
31560 _v = 1;
31561 }
31562 }
31563 if (_v) {
31564 return _wrap_Window_GetBorder__SWIG_1(self,args);
31565 }
31566 }
31567 if (argc == 2) {
31568 int _v;
31569 {
31570 void *ptr;
31571 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31572 _v = 0;
31573 PyErr_Clear();
31574 } else {
31575 _v = 1;
31576 }
31577 }
31578 if (_v) {
31579 _v = SWIG_Check_long(argv[1]);
31580 if (_v) {
31581 return _wrap_Window_GetBorder__SWIG_0(self,args);
31582 }
31583 }
31584 }
31585
31586 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
31587 return NULL;
31588 }
31589
31590
31591 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
31592 PyObject *resultobj = NULL;
31593 wxWindow *arg1 = (wxWindow *) 0 ;
31594 long arg2 = (long) wxUPDATE_UI_NONE ;
31595 PyObject * obj0 = 0 ;
31596 PyObject * obj1 = 0 ;
31597 char *kwnames[] = {
31598 (char *) "self",(char *) "flags", NULL
31599 };
31600
31601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
31602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31603 if (SWIG_arg_fail(1)) SWIG_fail;
31604 if (obj1) {
31605 {
31606 arg2 = static_cast<long >(SWIG_As_long(obj1));
31607 if (SWIG_arg_fail(2)) SWIG_fail;
31608 }
31609 }
31610 {
31611 PyThreadState* __tstate = wxPyBeginAllowThreads();
31612 (arg1)->UpdateWindowUI(arg2);
31613
31614 wxPyEndAllowThreads(__tstate);
31615 if (PyErr_Occurred()) SWIG_fail;
31616 }
31617 Py_INCREF(Py_None); resultobj = Py_None;
31618 return resultobj;
31619 fail:
31620 return NULL;
31621 }
31622
31623
31624 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
31625 PyObject *resultobj = NULL;
31626 wxWindow *arg1 = (wxWindow *) 0 ;
31627 wxMenu *arg2 = (wxMenu *) 0 ;
31628 int arg3 = (int) -1 ;
31629 int arg4 = (int) -1 ;
31630 bool result;
31631 PyObject * obj0 = 0 ;
31632 PyObject * obj1 = 0 ;
31633 PyObject * obj2 = 0 ;
31634 PyObject * obj3 = 0 ;
31635 char *kwnames[] = {
31636 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
31637 };
31638
31639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31641 if (SWIG_arg_fail(1)) SWIG_fail;
31642 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31643 if (SWIG_arg_fail(2)) SWIG_fail;
31644 if (obj2) {
31645 {
31646 arg3 = static_cast<int >(SWIG_As_int(obj2));
31647 if (SWIG_arg_fail(3)) SWIG_fail;
31648 }
31649 }
31650 if (obj3) {
31651 {
31652 arg4 = static_cast<int >(SWIG_As_int(obj3));
31653 if (SWIG_arg_fail(4)) SWIG_fail;
31654 }
31655 }
31656 {
31657 PyThreadState* __tstate = wxPyBeginAllowThreads();
31658 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
31659
31660 wxPyEndAllowThreads(__tstate);
31661 if (PyErr_Occurred()) SWIG_fail;
31662 }
31663 {
31664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31665 }
31666 return resultobj;
31667 fail:
31668 return NULL;
31669 }
31670
31671
31672 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
31673 PyObject *resultobj = NULL;
31674 wxWindow *arg1 = (wxWindow *) 0 ;
31675 wxMenu *arg2 = (wxMenu *) 0 ;
31676 wxPoint const &arg3_defvalue = wxDefaultPosition ;
31677 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
31678 bool result;
31679 wxPoint temp3 ;
31680 PyObject * obj0 = 0 ;
31681 PyObject * obj1 = 0 ;
31682 PyObject * obj2 = 0 ;
31683 char *kwnames[] = {
31684 (char *) "self",(char *) "menu",(char *) "pos", NULL
31685 };
31686
31687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
31688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31689 if (SWIG_arg_fail(1)) SWIG_fail;
31690 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31691 if (SWIG_arg_fail(2)) SWIG_fail;
31692 if (obj2) {
31693 {
31694 arg3 = &temp3;
31695 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
31696 }
31697 }
31698 {
31699 PyThreadState* __tstate = wxPyBeginAllowThreads();
31700 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
31701
31702 wxPyEndAllowThreads(__tstate);
31703 if (PyErr_Occurred()) SWIG_fail;
31704 }
31705 {
31706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31707 }
31708 return resultobj;
31709 fail:
31710 return NULL;
31711 }
31712
31713
31714 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31715 PyObject *resultobj = NULL;
31716 wxWindow *arg1 = (wxWindow *) 0 ;
31717 long result;
31718 PyObject * obj0 = 0 ;
31719 char *kwnames[] = {
31720 (char *) "self", NULL
31721 };
31722
31723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
31724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31725 if (SWIG_arg_fail(1)) SWIG_fail;
31726 {
31727 PyThreadState* __tstate = wxPyBeginAllowThreads();
31728 result = (long)wxWindow_GetHandle(arg1);
31729
31730 wxPyEndAllowThreads(__tstate);
31731 if (PyErr_Occurred()) SWIG_fail;
31732 }
31733 {
31734 resultobj = SWIG_From_long(static_cast<long >(result));
31735 }
31736 return resultobj;
31737 fail:
31738 return NULL;
31739 }
31740
31741
31742 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31743 PyObject *resultobj = NULL;
31744 wxWindow *arg1 = (wxWindow *) 0 ;
31745 long arg2 ;
31746 PyObject * obj0 = 0 ;
31747 PyObject * obj1 = 0 ;
31748 char *kwnames[] = {
31749 (char *) "self",(char *) "handle", NULL
31750 };
31751
31752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
31753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31754 if (SWIG_arg_fail(1)) SWIG_fail;
31755 {
31756 arg2 = static_cast<long >(SWIG_As_long(obj1));
31757 if (SWIG_arg_fail(2)) SWIG_fail;
31758 }
31759 {
31760 PyThreadState* __tstate = wxPyBeginAllowThreads();
31761 wxWindow_AssociateHandle(arg1,arg2);
31762
31763 wxPyEndAllowThreads(__tstate);
31764 if (PyErr_Occurred()) SWIG_fail;
31765 }
31766 Py_INCREF(Py_None); resultobj = Py_None;
31767 return resultobj;
31768 fail:
31769 return NULL;
31770 }
31771
31772
31773 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31774 PyObject *resultobj = NULL;
31775 wxWindow *arg1 = (wxWindow *) 0 ;
31776 PyObject * obj0 = 0 ;
31777 char *kwnames[] = {
31778 (char *) "self", NULL
31779 };
31780
31781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
31782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31783 if (SWIG_arg_fail(1)) SWIG_fail;
31784 {
31785 PyThreadState* __tstate = wxPyBeginAllowThreads();
31786 (arg1)->DissociateHandle();
31787
31788 wxPyEndAllowThreads(__tstate);
31789 if (PyErr_Occurred()) SWIG_fail;
31790 }
31791 Py_INCREF(Py_None); resultobj = Py_None;
31792 return resultobj;
31793 fail:
31794 return NULL;
31795 }
31796
31797
31798 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31799 PyObject *resultobj = NULL;
31800 wxWindow *arg1 = (wxWindow *) 0 ;
31801 int arg2 ;
31802 bool result;
31803 PyObject * obj0 = 0 ;
31804 PyObject * obj1 = 0 ;
31805 char *kwnames[] = {
31806 (char *) "self",(char *) "orient", NULL
31807 };
31808
31809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31811 if (SWIG_arg_fail(1)) SWIG_fail;
31812 {
31813 arg2 = static_cast<int >(SWIG_As_int(obj1));
31814 if (SWIG_arg_fail(2)) SWIG_fail;
31815 }
31816 {
31817 PyThreadState* __tstate = wxPyBeginAllowThreads();
31818 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31819
31820 wxPyEndAllowThreads(__tstate);
31821 if (PyErr_Occurred()) SWIG_fail;
31822 }
31823 {
31824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31825 }
31826 return resultobj;
31827 fail:
31828 return NULL;
31829 }
31830
31831
31832 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31833 PyObject *resultobj = NULL;
31834 wxWindow *arg1 = (wxWindow *) 0 ;
31835 int arg2 ;
31836 int arg3 ;
31837 int arg4 ;
31838 int arg5 ;
31839 bool arg6 = (bool) true ;
31840 PyObject * obj0 = 0 ;
31841 PyObject * obj1 = 0 ;
31842 PyObject * obj2 = 0 ;
31843 PyObject * obj3 = 0 ;
31844 PyObject * obj4 = 0 ;
31845 PyObject * obj5 = 0 ;
31846 char *kwnames[] = {
31847 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31848 };
31849
31850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31852 if (SWIG_arg_fail(1)) SWIG_fail;
31853 {
31854 arg2 = static_cast<int >(SWIG_As_int(obj1));
31855 if (SWIG_arg_fail(2)) SWIG_fail;
31856 }
31857 {
31858 arg3 = static_cast<int >(SWIG_As_int(obj2));
31859 if (SWIG_arg_fail(3)) SWIG_fail;
31860 }
31861 {
31862 arg4 = static_cast<int >(SWIG_As_int(obj3));
31863 if (SWIG_arg_fail(4)) SWIG_fail;
31864 }
31865 {
31866 arg5 = static_cast<int >(SWIG_As_int(obj4));
31867 if (SWIG_arg_fail(5)) SWIG_fail;
31868 }
31869 if (obj5) {
31870 {
31871 arg6 = static_cast<bool >(SWIG_As_bool(obj5));
31872 if (SWIG_arg_fail(6)) SWIG_fail;
31873 }
31874 }
31875 {
31876 PyThreadState* __tstate = wxPyBeginAllowThreads();
31877 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31878
31879 wxPyEndAllowThreads(__tstate);
31880 if (PyErr_Occurred()) SWIG_fail;
31881 }
31882 Py_INCREF(Py_None); resultobj = Py_None;
31883 return resultobj;
31884 fail:
31885 return NULL;
31886 }
31887
31888
31889 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31890 PyObject *resultobj = NULL;
31891 wxWindow *arg1 = (wxWindow *) 0 ;
31892 int arg2 ;
31893 int arg3 ;
31894 bool arg4 = (bool) true ;
31895 PyObject * obj0 = 0 ;
31896 PyObject * obj1 = 0 ;
31897 PyObject * obj2 = 0 ;
31898 PyObject * obj3 = 0 ;
31899 char *kwnames[] = {
31900 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31901 };
31902
31903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31905 if (SWIG_arg_fail(1)) SWIG_fail;
31906 {
31907 arg2 = static_cast<int >(SWIG_As_int(obj1));
31908 if (SWIG_arg_fail(2)) SWIG_fail;
31909 }
31910 {
31911 arg3 = static_cast<int >(SWIG_As_int(obj2));
31912 if (SWIG_arg_fail(3)) SWIG_fail;
31913 }
31914 if (obj3) {
31915 {
31916 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
31917 if (SWIG_arg_fail(4)) SWIG_fail;
31918 }
31919 }
31920 {
31921 PyThreadState* __tstate = wxPyBeginAllowThreads();
31922 (arg1)->SetScrollPos(arg2,arg3,arg4);
31923
31924 wxPyEndAllowThreads(__tstate);
31925 if (PyErr_Occurred()) SWIG_fail;
31926 }
31927 Py_INCREF(Py_None); resultobj = Py_None;
31928 return resultobj;
31929 fail:
31930 return NULL;
31931 }
31932
31933
31934 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31935 PyObject *resultobj = NULL;
31936 wxWindow *arg1 = (wxWindow *) 0 ;
31937 int arg2 ;
31938 int result;
31939 PyObject * obj0 = 0 ;
31940 PyObject * obj1 = 0 ;
31941 char *kwnames[] = {
31942 (char *) "self",(char *) "orientation", NULL
31943 };
31944
31945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31947 if (SWIG_arg_fail(1)) SWIG_fail;
31948 {
31949 arg2 = static_cast<int >(SWIG_As_int(obj1));
31950 if (SWIG_arg_fail(2)) SWIG_fail;
31951 }
31952 {
31953 PyThreadState* __tstate = wxPyBeginAllowThreads();
31954 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31955
31956 wxPyEndAllowThreads(__tstate);
31957 if (PyErr_Occurred()) SWIG_fail;
31958 }
31959 {
31960 resultobj = SWIG_From_int(static_cast<int >(result));
31961 }
31962 return resultobj;
31963 fail:
31964 return NULL;
31965 }
31966
31967
31968 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31969 PyObject *resultobj = NULL;
31970 wxWindow *arg1 = (wxWindow *) 0 ;
31971 int arg2 ;
31972 int result;
31973 PyObject * obj0 = 0 ;
31974 PyObject * obj1 = 0 ;
31975 char *kwnames[] = {
31976 (char *) "self",(char *) "orientation", NULL
31977 };
31978
31979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31981 if (SWIG_arg_fail(1)) SWIG_fail;
31982 {
31983 arg2 = static_cast<int >(SWIG_As_int(obj1));
31984 if (SWIG_arg_fail(2)) SWIG_fail;
31985 }
31986 {
31987 PyThreadState* __tstate = wxPyBeginAllowThreads();
31988 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31989
31990 wxPyEndAllowThreads(__tstate);
31991 if (PyErr_Occurred()) SWIG_fail;
31992 }
31993 {
31994 resultobj = SWIG_From_int(static_cast<int >(result));
31995 }
31996 return resultobj;
31997 fail:
31998 return NULL;
31999 }
32000
32001
32002 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
32003 PyObject *resultobj = NULL;
32004 wxWindow *arg1 = (wxWindow *) 0 ;
32005 int arg2 ;
32006 int result;
32007 PyObject * obj0 = 0 ;
32008 PyObject * obj1 = 0 ;
32009 char *kwnames[] = {
32010 (char *) "self",(char *) "orientation", NULL
32011 };
32012
32013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
32014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32015 if (SWIG_arg_fail(1)) SWIG_fail;
32016 {
32017 arg2 = static_cast<int >(SWIG_As_int(obj1));
32018 if (SWIG_arg_fail(2)) SWIG_fail;
32019 }
32020 {
32021 PyThreadState* __tstate = wxPyBeginAllowThreads();
32022 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
32023
32024 wxPyEndAllowThreads(__tstate);
32025 if (PyErr_Occurred()) SWIG_fail;
32026 }
32027 {
32028 resultobj = SWIG_From_int(static_cast<int >(result));
32029 }
32030 return resultobj;
32031 fail:
32032 return NULL;
32033 }
32034
32035
32036 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32037 PyObject *resultobj = NULL;
32038 wxWindow *arg1 = (wxWindow *) 0 ;
32039 int arg2 ;
32040 int arg3 ;
32041 wxRect *arg4 = (wxRect *) NULL ;
32042 PyObject * obj0 = 0 ;
32043 PyObject * obj1 = 0 ;
32044 PyObject * obj2 = 0 ;
32045 PyObject * obj3 = 0 ;
32046 char *kwnames[] = {
32047 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
32048 };
32049
32050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32052 if (SWIG_arg_fail(1)) SWIG_fail;
32053 {
32054 arg2 = static_cast<int >(SWIG_As_int(obj1));
32055 if (SWIG_arg_fail(2)) SWIG_fail;
32056 }
32057 {
32058 arg3 = static_cast<int >(SWIG_As_int(obj2));
32059 if (SWIG_arg_fail(3)) SWIG_fail;
32060 }
32061 if (obj3) {
32062 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
32063 if (SWIG_arg_fail(4)) SWIG_fail;
32064 }
32065 {
32066 PyThreadState* __tstate = wxPyBeginAllowThreads();
32067 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
32068
32069 wxPyEndAllowThreads(__tstate);
32070 if (PyErr_Occurred()) SWIG_fail;
32071 }
32072 Py_INCREF(Py_None); resultobj = Py_None;
32073 return resultobj;
32074 fail:
32075 return NULL;
32076 }
32077
32078
32079 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
32080 PyObject *resultobj = NULL;
32081 wxWindow *arg1 = (wxWindow *) 0 ;
32082 int arg2 ;
32083 bool result;
32084 PyObject * obj0 = 0 ;
32085 PyObject * obj1 = 0 ;
32086 char *kwnames[] = {
32087 (char *) "self",(char *) "lines", NULL
32088 };
32089
32090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
32091 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32092 if (SWIG_arg_fail(1)) SWIG_fail;
32093 {
32094 arg2 = static_cast<int >(SWIG_As_int(obj1));
32095 if (SWIG_arg_fail(2)) SWIG_fail;
32096 }
32097 {
32098 PyThreadState* __tstate = wxPyBeginAllowThreads();
32099 result = (bool)(arg1)->ScrollLines(arg2);
32100
32101 wxPyEndAllowThreads(__tstate);
32102 if (PyErr_Occurred()) SWIG_fail;
32103 }
32104 {
32105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32106 }
32107 return resultobj;
32108 fail:
32109 return NULL;
32110 }
32111
32112
32113 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
32114 PyObject *resultobj = NULL;
32115 wxWindow *arg1 = (wxWindow *) 0 ;
32116 int arg2 ;
32117 bool result;
32118 PyObject * obj0 = 0 ;
32119 PyObject * obj1 = 0 ;
32120 char *kwnames[] = {
32121 (char *) "self",(char *) "pages", NULL
32122 };
32123
32124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
32125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32126 if (SWIG_arg_fail(1)) SWIG_fail;
32127 {
32128 arg2 = static_cast<int >(SWIG_As_int(obj1));
32129 if (SWIG_arg_fail(2)) SWIG_fail;
32130 }
32131 {
32132 PyThreadState* __tstate = wxPyBeginAllowThreads();
32133 result = (bool)(arg1)->ScrollPages(arg2);
32134
32135 wxPyEndAllowThreads(__tstate);
32136 if (PyErr_Occurred()) SWIG_fail;
32137 }
32138 {
32139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32140 }
32141 return resultobj;
32142 fail:
32143 return NULL;
32144 }
32145
32146
32147 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
32148 PyObject *resultobj = NULL;
32149 wxWindow *arg1 = (wxWindow *) 0 ;
32150 bool result;
32151 PyObject * obj0 = 0 ;
32152 char *kwnames[] = {
32153 (char *) "self", NULL
32154 };
32155
32156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
32157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32158 if (SWIG_arg_fail(1)) SWIG_fail;
32159 {
32160 PyThreadState* __tstate = wxPyBeginAllowThreads();
32161 result = (bool)(arg1)->LineUp();
32162
32163 wxPyEndAllowThreads(__tstate);
32164 if (PyErr_Occurred()) SWIG_fail;
32165 }
32166 {
32167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32168 }
32169 return resultobj;
32170 fail:
32171 return NULL;
32172 }
32173
32174
32175 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
32176 PyObject *resultobj = NULL;
32177 wxWindow *arg1 = (wxWindow *) 0 ;
32178 bool result;
32179 PyObject * obj0 = 0 ;
32180 char *kwnames[] = {
32181 (char *) "self", NULL
32182 };
32183
32184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
32185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32186 if (SWIG_arg_fail(1)) SWIG_fail;
32187 {
32188 PyThreadState* __tstate = wxPyBeginAllowThreads();
32189 result = (bool)(arg1)->LineDown();
32190
32191 wxPyEndAllowThreads(__tstate);
32192 if (PyErr_Occurred()) SWIG_fail;
32193 }
32194 {
32195 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32196 }
32197 return resultobj;
32198 fail:
32199 return NULL;
32200 }
32201
32202
32203 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
32204 PyObject *resultobj = NULL;
32205 wxWindow *arg1 = (wxWindow *) 0 ;
32206 bool result;
32207 PyObject * obj0 = 0 ;
32208 char *kwnames[] = {
32209 (char *) "self", NULL
32210 };
32211
32212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
32213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32214 if (SWIG_arg_fail(1)) SWIG_fail;
32215 {
32216 PyThreadState* __tstate = wxPyBeginAllowThreads();
32217 result = (bool)(arg1)->PageUp();
32218
32219 wxPyEndAllowThreads(__tstate);
32220 if (PyErr_Occurred()) SWIG_fail;
32221 }
32222 {
32223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32224 }
32225 return resultobj;
32226 fail:
32227 return NULL;
32228 }
32229
32230
32231 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
32232 PyObject *resultobj = NULL;
32233 wxWindow *arg1 = (wxWindow *) 0 ;
32234 bool result;
32235 PyObject * obj0 = 0 ;
32236 char *kwnames[] = {
32237 (char *) "self", NULL
32238 };
32239
32240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
32241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32242 if (SWIG_arg_fail(1)) SWIG_fail;
32243 {
32244 PyThreadState* __tstate = wxPyBeginAllowThreads();
32245 result = (bool)(arg1)->PageDown();
32246
32247 wxPyEndAllowThreads(__tstate);
32248 if (PyErr_Occurred()) SWIG_fail;
32249 }
32250 {
32251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32252 }
32253 return resultobj;
32254 fail:
32255 return NULL;
32256 }
32257
32258
32259 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32260 PyObject *resultobj = NULL;
32261 wxWindow *arg1 = (wxWindow *) 0 ;
32262 wxString *arg2 = 0 ;
32263 bool temp2 = false ;
32264 PyObject * obj0 = 0 ;
32265 PyObject * obj1 = 0 ;
32266 char *kwnames[] = {
32267 (char *) "self",(char *) "text", NULL
32268 };
32269
32270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
32271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32272 if (SWIG_arg_fail(1)) SWIG_fail;
32273 {
32274 arg2 = wxString_in_helper(obj1);
32275 if (arg2 == NULL) SWIG_fail;
32276 temp2 = true;
32277 }
32278 {
32279 PyThreadState* __tstate = wxPyBeginAllowThreads();
32280 (arg1)->SetHelpText((wxString const &)*arg2);
32281
32282 wxPyEndAllowThreads(__tstate);
32283 if (PyErr_Occurred()) SWIG_fail;
32284 }
32285 Py_INCREF(Py_None); resultobj = Py_None;
32286 {
32287 if (temp2)
32288 delete arg2;
32289 }
32290 return resultobj;
32291 fail:
32292 {
32293 if (temp2)
32294 delete arg2;
32295 }
32296 return NULL;
32297 }
32298
32299
32300 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
32301 PyObject *resultobj = NULL;
32302 wxWindow *arg1 = (wxWindow *) 0 ;
32303 wxString *arg2 = 0 ;
32304 bool temp2 = false ;
32305 PyObject * obj0 = 0 ;
32306 PyObject * obj1 = 0 ;
32307 char *kwnames[] = {
32308 (char *) "self",(char *) "text", NULL
32309 };
32310
32311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
32312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32313 if (SWIG_arg_fail(1)) SWIG_fail;
32314 {
32315 arg2 = wxString_in_helper(obj1);
32316 if (arg2 == NULL) SWIG_fail;
32317 temp2 = true;
32318 }
32319 {
32320 PyThreadState* __tstate = wxPyBeginAllowThreads();
32321 (arg1)->SetHelpTextForId((wxString const &)*arg2);
32322
32323 wxPyEndAllowThreads(__tstate);
32324 if (PyErr_Occurred()) SWIG_fail;
32325 }
32326 Py_INCREF(Py_None); resultobj = Py_None;
32327 {
32328 if (temp2)
32329 delete arg2;
32330 }
32331 return resultobj;
32332 fail:
32333 {
32334 if (temp2)
32335 delete arg2;
32336 }
32337 return NULL;
32338 }
32339
32340
32341 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32342 PyObject *resultobj = NULL;
32343 wxWindow *arg1 = (wxWindow *) 0 ;
32344 wxString result;
32345 PyObject * obj0 = 0 ;
32346 char *kwnames[] = {
32347 (char *) "self", NULL
32348 };
32349
32350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
32351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32352 if (SWIG_arg_fail(1)) SWIG_fail;
32353 {
32354 PyThreadState* __tstate = wxPyBeginAllowThreads();
32355 result = ((wxWindow const *)arg1)->GetHelpText();
32356
32357 wxPyEndAllowThreads(__tstate);
32358 if (PyErr_Occurred()) SWIG_fail;
32359 }
32360 {
32361 #if wxUSE_UNICODE
32362 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32363 #else
32364 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32365 #endif
32366 }
32367 return resultobj;
32368 fail:
32369 return NULL;
32370 }
32371
32372
32373 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
32374 PyObject *resultobj = NULL;
32375 wxWindow *arg1 = (wxWindow *) 0 ;
32376 wxString *arg2 = 0 ;
32377 bool temp2 = false ;
32378 PyObject * obj0 = 0 ;
32379 PyObject * obj1 = 0 ;
32380 char *kwnames[] = {
32381 (char *) "self",(char *) "tip", NULL
32382 };
32383
32384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
32385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32386 if (SWIG_arg_fail(1)) SWIG_fail;
32387 {
32388 arg2 = wxString_in_helper(obj1);
32389 if (arg2 == NULL) SWIG_fail;
32390 temp2 = true;
32391 }
32392 {
32393 PyThreadState* __tstate = wxPyBeginAllowThreads();
32394 (arg1)->SetToolTip((wxString const &)*arg2);
32395
32396 wxPyEndAllowThreads(__tstate);
32397 if (PyErr_Occurred()) SWIG_fail;
32398 }
32399 Py_INCREF(Py_None); resultobj = Py_None;
32400 {
32401 if (temp2)
32402 delete arg2;
32403 }
32404 return resultobj;
32405 fail:
32406 {
32407 if (temp2)
32408 delete arg2;
32409 }
32410 return NULL;
32411 }
32412
32413
32414 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32415 PyObject *resultobj = NULL;
32416 wxWindow *arg1 = (wxWindow *) 0 ;
32417 wxToolTip *arg2 = (wxToolTip *) 0 ;
32418 PyObject * obj0 = 0 ;
32419 PyObject * obj1 = 0 ;
32420 char *kwnames[] = {
32421 (char *) "self",(char *) "tip", NULL
32422 };
32423
32424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
32425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32426 if (SWIG_arg_fail(1)) SWIG_fail;
32427 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32428 if (SWIG_arg_fail(2)) SWIG_fail;
32429 {
32430 PyThreadState* __tstate = wxPyBeginAllowThreads();
32431 (arg1)->SetToolTip(arg2);
32432
32433 wxPyEndAllowThreads(__tstate);
32434 if (PyErr_Occurred()) SWIG_fail;
32435 }
32436 Py_INCREF(Py_None); resultobj = Py_None;
32437 return resultobj;
32438 fail:
32439 return NULL;
32440 }
32441
32442
32443 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32444 PyObject *resultobj = NULL;
32445 wxWindow *arg1 = (wxWindow *) 0 ;
32446 wxToolTip *result;
32447 PyObject * obj0 = 0 ;
32448 char *kwnames[] = {
32449 (char *) "self", NULL
32450 };
32451
32452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
32453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32454 if (SWIG_arg_fail(1)) SWIG_fail;
32455 {
32456 PyThreadState* __tstate = wxPyBeginAllowThreads();
32457 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
32458
32459 wxPyEndAllowThreads(__tstate);
32460 if (PyErr_Occurred()) SWIG_fail;
32461 }
32462 {
32463 resultobj = wxPyMake_wxObject(result, (bool)0);
32464 }
32465 return resultobj;
32466 fail:
32467 return NULL;
32468 }
32469
32470
32471 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32472 PyObject *resultobj = NULL;
32473 wxWindow *arg1 = (wxWindow *) 0 ;
32474 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
32475 PyObject * obj0 = 0 ;
32476 PyObject * obj1 = 0 ;
32477 char *kwnames[] = {
32478 (char *) "self",(char *) "dropTarget", NULL
32479 };
32480
32481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
32482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32483 if (SWIG_arg_fail(1)) SWIG_fail;
32484 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32485 if (SWIG_arg_fail(2)) SWIG_fail;
32486 {
32487 PyThreadState* __tstate = wxPyBeginAllowThreads();
32488 (arg1)->SetDropTarget(arg2);
32489
32490 wxPyEndAllowThreads(__tstate);
32491 if (PyErr_Occurred()) SWIG_fail;
32492 }
32493 Py_INCREF(Py_None); resultobj = Py_None;
32494 return resultobj;
32495 fail:
32496 return NULL;
32497 }
32498
32499
32500 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32501 PyObject *resultobj = NULL;
32502 wxWindow *arg1 = (wxWindow *) 0 ;
32503 wxPyDropTarget *result;
32504 PyObject * obj0 = 0 ;
32505 char *kwnames[] = {
32506 (char *) "self", NULL
32507 };
32508
32509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
32510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32511 if (SWIG_arg_fail(1)) SWIG_fail;
32512 {
32513 PyThreadState* __tstate = wxPyBeginAllowThreads();
32514 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
32515
32516 wxPyEndAllowThreads(__tstate);
32517 if (PyErr_Occurred()) SWIG_fail;
32518 }
32519 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
32520 return resultobj;
32521 fail:
32522 return NULL;
32523 }
32524
32525
32526 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
32527 PyObject *resultobj = NULL;
32528 wxWindow *arg1 = (wxWindow *) 0 ;
32529 bool arg2 ;
32530 PyObject * obj0 = 0 ;
32531 PyObject * obj1 = 0 ;
32532 char *kwnames[] = {
32533 (char *) "self",(char *) "accept", NULL
32534 };
32535
32536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
32537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32538 if (SWIG_arg_fail(1)) SWIG_fail;
32539 {
32540 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
32541 if (SWIG_arg_fail(2)) SWIG_fail;
32542 }
32543 {
32544 PyThreadState* __tstate = wxPyBeginAllowThreads();
32545 wxWindow_DragAcceptFiles(arg1,arg2);
32546
32547 wxPyEndAllowThreads(__tstate);
32548 if (PyErr_Occurred()) SWIG_fail;
32549 }
32550 Py_INCREF(Py_None); resultobj = Py_None;
32551 return resultobj;
32552 fail:
32553 return NULL;
32554 }
32555
32556
32557 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32558 PyObject *resultobj = NULL;
32559 wxWindow *arg1 = (wxWindow *) 0 ;
32560 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
32561 PyObject * obj0 = 0 ;
32562 PyObject * obj1 = 0 ;
32563 char *kwnames[] = {
32564 (char *) "self",(char *) "constraints", NULL
32565 };
32566
32567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
32568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32569 if (SWIG_arg_fail(1)) SWIG_fail;
32570 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
32571 if (SWIG_arg_fail(2)) SWIG_fail;
32572 {
32573 PyThreadState* __tstate = wxPyBeginAllowThreads();
32574 (arg1)->SetConstraints(arg2);
32575
32576 wxPyEndAllowThreads(__tstate);
32577 if (PyErr_Occurred()) SWIG_fail;
32578 }
32579 Py_INCREF(Py_None); resultobj = Py_None;
32580 return resultobj;
32581 fail:
32582 return NULL;
32583 }
32584
32585
32586 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32587 PyObject *resultobj = NULL;
32588 wxWindow *arg1 = (wxWindow *) 0 ;
32589 wxLayoutConstraints *result;
32590 PyObject * obj0 = 0 ;
32591 char *kwnames[] = {
32592 (char *) "self", NULL
32593 };
32594
32595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
32596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32597 if (SWIG_arg_fail(1)) SWIG_fail;
32598 {
32599 PyThreadState* __tstate = wxPyBeginAllowThreads();
32600 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
32601
32602 wxPyEndAllowThreads(__tstate);
32603 if (PyErr_Occurred()) SWIG_fail;
32604 }
32605 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
32606 return resultobj;
32607 fail:
32608 return NULL;
32609 }
32610
32611
32612 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32613 PyObject *resultobj = NULL;
32614 wxWindow *arg1 = (wxWindow *) 0 ;
32615 bool arg2 ;
32616 PyObject * obj0 = 0 ;
32617 PyObject * obj1 = 0 ;
32618 char *kwnames[] = {
32619 (char *) "self",(char *) "autoLayout", NULL
32620 };
32621
32622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
32623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32624 if (SWIG_arg_fail(1)) SWIG_fail;
32625 {
32626 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
32627 if (SWIG_arg_fail(2)) SWIG_fail;
32628 }
32629 {
32630 PyThreadState* __tstate = wxPyBeginAllowThreads();
32631 (arg1)->SetAutoLayout(arg2);
32632
32633 wxPyEndAllowThreads(__tstate);
32634 if (PyErr_Occurred()) SWIG_fail;
32635 }
32636 Py_INCREF(Py_None); resultobj = Py_None;
32637 return resultobj;
32638 fail:
32639 return NULL;
32640 }
32641
32642
32643 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32644 PyObject *resultobj = NULL;
32645 wxWindow *arg1 = (wxWindow *) 0 ;
32646 bool result;
32647 PyObject * obj0 = 0 ;
32648 char *kwnames[] = {
32649 (char *) "self", NULL
32650 };
32651
32652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
32653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32654 if (SWIG_arg_fail(1)) SWIG_fail;
32655 {
32656 PyThreadState* __tstate = wxPyBeginAllowThreads();
32657 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
32658
32659 wxPyEndAllowThreads(__tstate);
32660 if (PyErr_Occurred()) SWIG_fail;
32661 }
32662 {
32663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32664 }
32665 return resultobj;
32666 fail:
32667 return NULL;
32668 }
32669
32670
32671 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
32672 PyObject *resultobj = NULL;
32673 wxWindow *arg1 = (wxWindow *) 0 ;
32674 bool result;
32675 PyObject * obj0 = 0 ;
32676 char *kwnames[] = {
32677 (char *) "self", NULL
32678 };
32679
32680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
32681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32682 if (SWIG_arg_fail(1)) SWIG_fail;
32683 {
32684 PyThreadState* __tstate = wxPyBeginAllowThreads();
32685 result = (bool)(arg1)->Layout();
32686
32687 wxPyEndAllowThreads(__tstate);
32688 if (PyErr_Occurred()) SWIG_fail;
32689 }
32690 {
32691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32692 }
32693 return resultobj;
32694 fail:
32695 return NULL;
32696 }
32697
32698
32699 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32700 PyObject *resultobj = NULL;
32701 wxWindow *arg1 = (wxWindow *) 0 ;
32702 wxSizer *arg2 = (wxSizer *) 0 ;
32703 bool arg3 = (bool) true ;
32704 PyObject * obj0 = 0 ;
32705 PyObject * obj1 = 0 ;
32706 PyObject * obj2 = 0 ;
32707 char *kwnames[] = {
32708 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32709 };
32710
32711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
32712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32713 if (SWIG_arg_fail(1)) SWIG_fail;
32714 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32715 if (SWIG_arg_fail(2)) SWIG_fail;
32716 if (obj2) {
32717 {
32718 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
32719 if (SWIG_arg_fail(3)) SWIG_fail;
32720 }
32721 }
32722 {
32723 PyThreadState* __tstate = wxPyBeginAllowThreads();
32724 (arg1)->SetSizer(arg2,arg3);
32725
32726 wxPyEndAllowThreads(__tstate);
32727 if (PyErr_Occurred()) SWIG_fail;
32728 }
32729 Py_INCREF(Py_None); resultobj = Py_None;
32730 return resultobj;
32731 fail:
32732 return NULL;
32733 }
32734
32735
32736 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
32737 PyObject *resultobj = NULL;
32738 wxWindow *arg1 = (wxWindow *) 0 ;
32739 wxSizer *arg2 = (wxSizer *) 0 ;
32740 bool arg3 = (bool) true ;
32741 PyObject * obj0 = 0 ;
32742 PyObject * obj1 = 0 ;
32743 PyObject * obj2 = 0 ;
32744 char *kwnames[] = {
32745 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32746 };
32747
32748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
32749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32750 if (SWIG_arg_fail(1)) SWIG_fail;
32751 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32752 if (SWIG_arg_fail(2)) SWIG_fail;
32753 if (obj2) {
32754 {
32755 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
32756 if (SWIG_arg_fail(3)) SWIG_fail;
32757 }
32758 }
32759 {
32760 PyThreadState* __tstate = wxPyBeginAllowThreads();
32761 (arg1)->SetSizerAndFit(arg2,arg3);
32762
32763 wxPyEndAllowThreads(__tstate);
32764 if (PyErr_Occurred()) SWIG_fail;
32765 }
32766 Py_INCREF(Py_None); resultobj = Py_None;
32767 return resultobj;
32768 fail:
32769 return NULL;
32770 }
32771
32772
32773 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32774 PyObject *resultobj = NULL;
32775 wxWindow *arg1 = (wxWindow *) 0 ;
32776 wxSizer *result;
32777 PyObject * obj0 = 0 ;
32778 char *kwnames[] = {
32779 (char *) "self", NULL
32780 };
32781
32782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32784 if (SWIG_arg_fail(1)) SWIG_fail;
32785 {
32786 PyThreadState* __tstate = wxPyBeginAllowThreads();
32787 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32788
32789 wxPyEndAllowThreads(__tstate);
32790 if (PyErr_Occurred()) SWIG_fail;
32791 }
32792 {
32793 resultobj = wxPyMake_wxObject(result, (bool)0);
32794 }
32795 return resultobj;
32796 fail:
32797 return NULL;
32798 }
32799
32800
32801 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32802 PyObject *resultobj = NULL;
32803 wxWindow *arg1 = (wxWindow *) 0 ;
32804 wxSizer *arg2 = (wxSizer *) 0 ;
32805 PyObject * obj0 = 0 ;
32806 PyObject * obj1 = 0 ;
32807 char *kwnames[] = {
32808 (char *) "self",(char *) "sizer", NULL
32809 };
32810
32811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32813 if (SWIG_arg_fail(1)) SWIG_fail;
32814 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32815 if (SWIG_arg_fail(2)) SWIG_fail;
32816 {
32817 PyThreadState* __tstate = wxPyBeginAllowThreads();
32818 (arg1)->SetContainingSizer(arg2);
32819
32820 wxPyEndAllowThreads(__tstate);
32821 if (PyErr_Occurred()) SWIG_fail;
32822 }
32823 Py_INCREF(Py_None); resultobj = Py_None;
32824 return resultobj;
32825 fail:
32826 return NULL;
32827 }
32828
32829
32830 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32831 PyObject *resultobj = NULL;
32832 wxWindow *arg1 = (wxWindow *) 0 ;
32833 wxSizer *result;
32834 PyObject * obj0 = 0 ;
32835 char *kwnames[] = {
32836 (char *) "self", NULL
32837 };
32838
32839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32841 if (SWIG_arg_fail(1)) SWIG_fail;
32842 {
32843 PyThreadState* __tstate = wxPyBeginAllowThreads();
32844 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32845
32846 wxPyEndAllowThreads(__tstate);
32847 if (PyErr_Occurred()) SWIG_fail;
32848 }
32849 {
32850 resultobj = wxPyMake_wxObject(result, (bool)0);
32851 }
32852 return resultobj;
32853 fail:
32854 return NULL;
32855 }
32856
32857
32858 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32859 PyObject *resultobj = NULL;
32860 wxWindow *arg1 = (wxWindow *) 0 ;
32861 PyObject * obj0 = 0 ;
32862 char *kwnames[] = {
32863 (char *) "self", NULL
32864 };
32865
32866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32868 if (SWIG_arg_fail(1)) SWIG_fail;
32869 {
32870 PyThreadState* __tstate = wxPyBeginAllowThreads();
32871 (arg1)->InheritAttributes();
32872
32873 wxPyEndAllowThreads(__tstate);
32874 if (PyErr_Occurred()) SWIG_fail;
32875 }
32876 Py_INCREF(Py_None); resultobj = Py_None;
32877 return resultobj;
32878 fail:
32879 return NULL;
32880 }
32881
32882
32883 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32884 PyObject *resultobj = NULL;
32885 wxWindow *arg1 = (wxWindow *) 0 ;
32886 bool result;
32887 PyObject * obj0 = 0 ;
32888 char *kwnames[] = {
32889 (char *) "self", NULL
32890 };
32891
32892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32894 if (SWIG_arg_fail(1)) SWIG_fail;
32895 {
32896 PyThreadState* __tstate = wxPyBeginAllowThreads();
32897 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32898
32899 wxPyEndAllowThreads(__tstate);
32900 if (PyErr_Occurred()) SWIG_fail;
32901 }
32902 {
32903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32904 }
32905 return resultobj;
32906 fail:
32907 return NULL;
32908 }
32909
32910
32911 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32912 PyObject *obj;
32913 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32914 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32915 Py_INCREF(obj);
32916 return Py_BuildValue((char *)"");
32917 }
32918 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32919 PyObject *resultobj = NULL;
32920 long arg1 ;
32921 wxWindow *arg2 = (wxWindow *) NULL ;
32922 wxWindow *result;
32923 PyObject * obj0 = 0 ;
32924 PyObject * obj1 = 0 ;
32925 char *kwnames[] = {
32926 (char *) "id",(char *) "parent", NULL
32927 };
32928
32929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32930 {
32931 arg1 = static_cast<long >(SWIG_As_long(obj0));
32932 if (SWIG_arg_fail(1)) SWIG_fail;
32933 }
32934 if (obj1) {
32935 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32936 if (SWIG_arg_fail(2)) SWIG_fail;
32937 }
32938 {
32939 if (!wxPyCheckForApp()) SWIG_fail;
32940 PyThreadState* __tstate = wxPyBeginAllowThreads();
32941 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32942
32943 wxPyEndAllowThreads(__tstate);
32944 if (PyErr_Occurred()) SWIG_fail;
32945 }
32946 {
32947 resultobj = wxPyMake_wxObject(result, 0);
32948 }
32949 return resultobj;
32950 fail:
32951 return NULL;
32952 }
32953
32954
32955 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32956 PyObject *resultobj = NULL;
32957 wxString *arg1 = 0 ;
32958 wxWindow *arg2 = (wxWindow *) NULL ;
32959 wxWindow *result;
32960 bool temp1 = false ;
32961 PyObject * obj0 = 0 ;
32962 PyObject * obj1 = 0 ;
32963 char *kwnames[] = {
32964 (char *) "name",(char *) "parent", NULL
32965 };
32966
32967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32968 {
32969 arg1 = wxString_in_helper(obj0);
32970 if (arg1 == NULL) SWIG_fail;
32971 temp1 = true;
32972 }
32973 if (obj1) {
32974 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32975 if (SWIG_arg_fail(2)) SWIG_fail;
32976 }
32977 {
32978 if (!wxPyCheckForApp()) SWIG_fail;
32979 PyThreadState* __tstate = wxPyBeginAllowThreads();
32980 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32981
32982 wxPyEndAllowThreads(__tstate);
32983 if (PyErr_Occurred()) SWIG_fail;
32984 }
32985 {
32986 resultobj = wxPyMake_wxObject(result, 0);
32987 }
32988 {
32989 if (temp1)
32990 delete arg1;
32991 }
32992 return resultobj;
32993 fail:
32994 {
32995 if (temp1)
32996 delete arg1;
32997 }
32998 return NULL;
32999 }
33000
33001
33002 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33003 PyObject *resultobj = NULL;
33004 wxString *arg1 = 0 ;
33005 wxWindow *arg2 = (wxWindow *) NULL ;
33006 wxWindow *result;
33007 bool temp1 = false ;
33008 PyObject * obj0 = 0 ;
33009 PyObject * obj1 = 0 ;
33010 char *kwnames[] = {
33011 (char *) "label",(char *) "parent", NULL
33012 };
33013
33014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
33015 {
33016 arg1 = wxString_in_helper(obj0);
33017 if (arg1 == NULL) SWIG_fail;
33018 temp1 = true;
33019 }
33020 if (obj1) {
33021 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33022 if (SWIG_arg_fail(2)) SWIG_fail;
33023 }
33024 {
33025 if (!wxPyCheckForApp()) SWIG_fail;
33026 PyThreadState* __tstate = wxPyBeginAllowThreads();
33027 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
33028
33029 wxPyEndAllowThreads(__tstate);
33030 if (PyErr_Occurred()) SWIG_fail;
33031 }
33032 {
33033 resultobj = wxPyMake_wxObject(result, 0);
33034 }
33035 {
33036 if (temp1)
33037 delete arg1;
33038 }
33039 return resultobj;
33040 fail:
33041 {
33042 if (temp1)
33043 delete arg1;
33044 }
33045 return NULL;
33046 }
33047
33048
33049 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
33050 PyObject *resultobj = NULL;
33051 wxWindow *arg1 = (wxWindow *) 0 ;
33052 unsigned long arg2 ;
33053 wxWindow *result;
33054 PyObject * obj0 = 0 ;
33055 PyObject * obj1 = 0 ;
33056 char *kwnames[] = {
33057 (char *) "parent",(char *) "_hWnd", NULL
33058 };
33059
33060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
33061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33062 if (SWIG_arg_fail(1)) SWIG_fail;
33063 {
33064 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
33065 if (SWIG_arg_fail(2)) SWIG_fail;
33066 }
33067 {
33068 PyThreadState* __tstate = wxPyBeginAllowThreads();
33069 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
33070
33071 wxPyEndAllowThreads(__tstate);
33072 if (PyErr_Occurred()) SWIG_fail;
33073 }
33074 {
33075 resultobj = wxPyMake_wxObject(result, 0);
33076 }
33077 return resultobj;
33078 fail:
33079 return NULL;
33080 }
33081
33082
33083 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
33084 PyObject *resultobj = NULL;
33085 PyObject *result;
33086 char *kwnames[] = {
33087 NULL
33088 };
33089
33090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
33091 {
33092 PyThreadState* __tstate = wxPyBeginAllowThreads();
33093 result = (PyObject *)GetTopLevelWindows();
33094
33095 wxPyEndAllowThreads(__tstate);
33096 if (PyErr_Occurred()) SWIG_fail;
33097 }
33098 resultobj = result;
33099 return resultobj;
33100 fail:
33101 return NULL;
33102 }
33103
33104
33105 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
33106 PyObject *resultobj = NULL;
33107 wxValidator *result;
33108 char *kwnames[] = {
33109 NULL
33110 };
33111
33112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
33113 {
33114 PyThreadState* __tstate = wxPyBeginAllowThreads();
33115 result = (wxValidator *)new wxValidator();
33116
33117 wxPyEndAllowThreads(__tstate);
33118 if (PyErr_Occurred()) SWIG_fail;
33119 }
33120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
33121 return resultobj;
33122 fail:
33123 return NULL;
33124 }
33125
33126
33127 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
33128 PyObject *resultobj = NULL;
33129 wxValidator *arg1 = (wxValidator *) 0 ;
33130 wxValidator *result;
33131 PyObject * obj0 = 0 ;
33132 char *kwnames[] = {
33133 (char *) "self", NULL
33134 };
33135
33136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
33137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33138 if (SWIG_arg_fail(1)) SWIG_fail;
33139 {
33140 PyThreadState* __tstate = wxPyBeginAllowThreads();
33141 result = (wxValidator *)(arg1)->Clone();
33142
33143 wxPyEndAllowThreads(__tstate);
33144 if (PyErr_Occurred()) SWIG_fail;
33145 }
33146 {
33147 resultobj = wxPyMake_wxObject(result, 0);
33148 }
33149 return resultobj;
33150 fail:
33151 return NULL;
33152 }
33153
33154
33155 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
33156 PyObject *resultobj = NULL;
33157 wxValidator *arg1 = (wxValidator *) 0 ;
33158 wxWindow *arg2 = (wxWindow *) 0 ;
33159 bool result;
33160 PyObject * obj0 = 0 ;
33161 PyObject * obj1 = 0 ;
33162 char *kwnames[] = {
33163 (char *) "self",(char *) "parent", NULL
33164 };
33165
33166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
33167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33168 if (SWIG_arg_fail(1)) SWIG_fail;
33169 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33170 if (SWIG_arg_fail(2)) SWIG_fail;
33171 {
33172 PyThreadState* __tstate = wxPyBeginAllowThreads();
33173 result = (bool)(arg1)->Validate(arg2);
33174
33175 wxPyEndAllowThreads(__tstate);
33176 if (PyErr_Occurred()) SWIG_fail;
33177 }
33178 {
33179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33180 }
33181 return resultobj;
33182 fail:
33183 return NULL;
33184 }
33185
33186
33187 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33188 PyObject *resultobj = NULL;
33189 wxValidator *arg1 = (wxValidator *) 0 ;
33190 bool result;
33191 PyObject * obj0 = 0 ;
33192 char *kwnames[] = {
33193 (char *) "self", NULL
33194 };
33195
33196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
33197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33198 if (SWIG_arg_fail(1)) SWIG_fail;
33199 {
33200 PyThreadState* __tstate = wxPyBeginAllowThreads();
33201 result = (bool)(arg1)->TransferToWindow();
33202
33203 wxPyEndAllowThreads(__tstate);
33204 if (PyErr_Occurred()) SWIG_fail;
33205 }
33206 {
33207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33208 }
33209 return resultobj;
33210 fail:
33211 return NULL;
33212 }
33213
33214
33215 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33216 PyObject *resultobj = NULL;
33217 wxValidator *arg1 = (wxValidator *) 0 ;
33218 bool result;
33219 PyObject * obj0 = 0 ;
33220 char *kwnames[] = {
33221 (char *) "self", NULL
33222 };
33223
33224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
33225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33226 if (SWIG_arg_fail(1)) SWIG_fail;
33227 {
33228 PyThreadState* __tstate = wxPyBeginAllowThreads();
33229 result = (bool)(arg1)->TransferFromWindow();
33230
33231 wxPyEndAllowThreads(__tstate);
33232 if (PyErr_Occurred()) SWIG_fail;
33233 }
33234 {
33235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33236 }
33237 return resultobj;
33238 fail:
33239 return NULL;
33240 }
33241
33242
33243 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33244 PyObject *resultobj = NULL;
33245 wxValidator *arg1 = (wxValidator *) 0 ;
33246 wxWindow *result;
33247 PyObject * obj0 = 0 ;
33248 char *kwnames[] = {
33249 (char *) "self", NULL
33250 };
33251
33252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
33253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33254 if (SWIG_arg_fail(1)) SWIG_fail;
33255 {
33256 PyThreadState* __tstate = wxPyBeginAllowThreads();
33257 result = (wxWindow *)(arg1)->GetWindow();
33258
33259 wxPyEndAllowThreads(__tstate);
33260 if (PyErr_Occurred()) SWIG_fail;
33261 }
33262 {
33263 resultobj = wxPyMake_wxObject(result, 0);
33264 }
33265 return resultobj;
33266 fail:
33267 return NULL;
33268 }
33269
33270
33271 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33272 PyObject *resultobj = NULL;
33273 wxValidator *arg1 = (wxValidator *) 0 ;
33274 wxWindow *arg2 = (wxWindow *) 0 ;
33275 PyObject * obj0 = 0 ;
33276 PyObject * obj1 = 0 ;
33277 char *kwnames[] = {
33278 (char *) "self",(char *) "window", NULL
33279 };
33280
33281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
33282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33283 if (SWIG_arg_fail(1)) SWIG_fail;
33284 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33285 if (SWIG_arg_fail(2)) SWIG_fail;
33286 {
33287 PyThreadState* __tstate = wxPyBeginAllowThreads();
33288 (arg1)->SetWindow(arg2);
33289
33290 wxPyEndAllowThreads(__tstate);
33291 if (PyErr_Occurred()) SWIG_fail;
33292 }
33293 Py_INCREF(Py_None); resultobj = Py_None;
33294 return resultobj;
33295 fail:
33296 return NULL;
33297 }
33298
33299
33300 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
33301 PyObject *resultobj = NULL;
33302 bool result;
33303 char *kwnames[] = {
33304 NULL
33305 };
33306
33307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
33308 {
33309 PyThreadState* __tstate = wxPyBeginAllowThreads();
33310 result = (bool)wxValidator::IsSilent();
33311
33312 wxPyEndAllowThreads(__tstate);
33313 if (PyErr_Occurred()) SWIG_fail;
33314 }
33315 {
33316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33317 }
33318 return resultobj;
33319 fail:
33320 return NULL;
33321 }
33322
33323
33324 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
33325 PyObject *resultobj = NULL;
33326 int arg1 = (int) true ;
33327 PyObject * obj0 = 0 ;
33328 char *kwnames[] = {
33329 (char *) "doIt", NULL
33330 };
33331
33332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
33333 if (obj0) {
33334 {
33335 arg1 = static_cast<int >(SWIG_As_int(obj0));
33336 if (SWIG_arg_fail(1)) SWIG_fail;
33337 }
33338 }
33339 {
33340 PyThreadState* __tstate = wxPyBeginAllowThreads();
33341 wxValidator::SetBellOnError(arg1);
33342
33343 wxPyEndAllowThreads(__tstate);
33344 if (PyErr_Occurred()) SWIG_fail;
33345 }
33346 Py_INCREF(Py_None); resultobj = Py_None;
33347 return resultobj;
33348 fail:
33349 return NULL;
33350 }
33351
33352
33353 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
33354 PyObject *obj;
33355 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33356 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
33357 Py_INCREF(obj);
33358 return Py_BuildValue((char *)"");
33359 }
33360 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
33361 PyObject *resultobj = NULL;
33362 wxPyValidator *result;
33363 char *kwnames[] = {
33364 NULL
33365 };
33366
33367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
33368 {
33369 PyThreadState* __tstate = wxPyBeginAllowThreads();
33370 result = (wxPyValidator *)new wxPyValidator();
33371
33372 wxPyEndAllowThreads(__tstate);
33373 if (PyErr_Occurred()) SWIG_fail;
33374 }
33375 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
33376 return resultobj;
33377 fail:
33378 return NULL;
33379 }
33380
33381
33382 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
33383 PyObject *resultobj = NULL;
33384 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
33385 PyObject *arg2 = (PyObject *) 0 ;
33386 PyObject *arg3 = (PyObject *) 0 ;
33387 int arg4 = (int) true ;
33388 PyObject * obj0 = 0 ;
33389 PyObject * obj1 = 0 ;
33390 PyObject * obj2 = 0 ;
33391 PyObject * obj3 = 0 ;
33392 char *kwnames[] = {
33393 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33394 };
33395
33396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
33398 if (SWIG_arg_fail(1)) SWIG_fail;
33399 arg2 = obj1;
33400 arg3 = obj2;
33401 if (obj3) {
33402 {
33403 arg4 = static_cast<int >(SWIG_As_int(obj3));
33404 if (SWIG_arg_fail(4)) SWIG_fail;
33405 }
33406 }
33407 {
33408 PyThreadState* __tstate = wxPyBeginAllowThreads();
33409 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33410
33411 wxPyEndAllowThreads(__tstate);
33412 if (PyErr_Occurred()) SWIG_fail;
33413 }
33414 Py_INCREF(Py_None); resultobj = Py_None;
33415 return resultobj;
33416 fail:
33417 return NULL;
33418 }
33419
33420
33421 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
33422 PyObject *obj;
33423 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33424 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
33425 Py_INCREF(obj);
33426 return Py_BuildValue((char *)"");
33427 }
33428 static int _wrap_DefaultValidator_set(PyObject *) {
33429 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
33430 return 1;
33431 }
33432
33433
33434 static PyObject *_wrap_DefaultValidator_get(void) {
33435 PyObject *pyobj = NULL;
33436
33437 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
33438 return pyobj;
33439 }
33440
33441
33442 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
33443 PyObject *resultobj = NULL;
33444 wxString const &arg1_defvalue = wxPyEmptyString ;
33445 wxString *arg1 = (wxString *) &arg1_defvalue ;
33446 long arg2 = (long) 0 ;
33447 wxMenu *result;
33448 bool temp1 = false ;
33449 PyObject * obj0 = 0 ;
33450 PyObject * obj1 = 0 ;
33451 char *kwnames[] = {
33452 (char *) "title",(char *) "style", NULL
33453 };
33454
33455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
33456 if (obj0) {
33457 {
33458 arg1 = wxString_in_helper(obj0);
33459 if (arg1 == NULL) SWIG_fail;
33460 temp1 = true;
33461 }
33462 }
33463 if (obj1) {
33464 {
33465 arg2 = static_cast<long >(SWIG_As_long(obj1));
33466 if (SWIG_arg_fail(2)) SWIG_fail;
33467 }
33468 }
33469 {
33470 if (!wxPyCheckForApp()) SWIG_fail;
33471 PyThreadState* __tstate = wxPyBeginAllowThreads();
33472 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
33473
33474 wxPyEndAllowThreads(__tstate);
33475 if (PyErr_Occurred()) SWIG_fail;
33476 }
33477 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
33478 {
33479 if (temp1)
33480 delete arg1;
33481 }
33482 return resultobj;
33483 fail:
33484 {
33485 if (temp1)
33486 delete arg1;
33487 }
33488 return NULL;
33489 }
33490
33491
33492 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
33493 PyObject *resultobj = NULL;
33494 wxMenu *arg1 = (wxMenu *) 0 ;
33495 int arg2 ;
33496 wxString *arg3 = 0 ;
33497 wxString const &arg4_defvalue = wxPyEmptyString ;
33498 wxString *arg4 = (wxString *) &arg4_defvalue ;
33499 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33500 wxMenuItem *result;
33501 bool temp3 = false ;
33502 bool temp4 = false ;
33503 PyObject * obj0 = 0 ;
33504 PyObject * obj1 = 0 ;
33505 PyObject * obj2 = 0 ;
33506 PyObject * obj3 = 0 ;
33507 PyObject * obj4 = 0 ;
33508 char *kwnames[] = {
33509 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33510 };
33511
33512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33514 if (SWIG_arg_fail(1)) SWIG_fail;
33515 {
33516 arg2 = static_cast<int >(SWIG_As_int(obj1));
33517 if (SWIG_arg_fail(2)) SWIG_fail;
33518 }
33519 {
33520 arg3 = wxString_in_helper(obj2);
33521 if (arg3 == NULL) SWIG_fail;
33522 temp3 = true;
33523 }
33524 if (obj3) {
33525 {
33526 arg4 = wxString_in_helper(obj3);
33527 if (arg4 == NULL) SWIG_fail;
33528 temp4 = true;
33529 }
33530 }
33531 if (obj4) {
33532 {
33533 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
33534 if (SWIG_arg_fail(5)) SWIG_fail;
33535 }
33536 }
33537 {
33538 PyThreadState* __tstate = wxPyBeginAllowThreads();
33539 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
33540
33541 wxPyEndAllowThreads(__tstate);
33542 if (PyErr_Occurred()) SWIG_fail;
33543 }
33544 {
33545 resultobj = wxPyMake_wxObject(result, (bool)0);
33546 }
33547 {
33548 if (temp3)
33549 delete arg3;
33550 }
33551 {
33552 if (temp4)
33553 delete arg4;
33554 }
33555 return resultobj;
33556 fail:
33557 {
33558 if (temp3)
33559 delete arg3;
33560 }
33561 {
33562 if (temp4)
33563 delete arg4;
33564 }
33565 return NULL;
33566 }
33567
33568
33569 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33570 PyObject *resultobj = NULL;
33571 wxMenu *arg1 = (wxMenu *) 0 ;
33572 wxMenuItem *result;
33573 PyObject * obj0 = 0 ;
33574 char *kwnames[] = {
33575 (char *) "self", NULL
33576 };
33577
33578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
33579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33580 if (SWIG_arg_fail(1)) SWIG_fail;
33581 {
33582 PyThreadState* __tstate = wxPyBeginAllowThreads();
33583 result = (wxMenuItem *)(arg1)->AppendSeparator();
33584
33585 wxPyEndAllowThreads(__tstate);
33586 if (PyErr_Occurred()) SWIG_fail;
33587 }
33588 {
33589 resultobj = wxPyMake_wxObject(result, (bool)0);
33590 }
33591 return resultobj;
33592 fail:
33593 return NULL;
33594 }
33595
33596
33597 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33598 PyObject *resultobj = NULL;
33599 wxMenu *arg1 = (wxMenu *) 0 ;
33600 int arg2 ;
33601 wxString *arg3 = 0 ;
33602 wxString const &arg4_defvalue = wxPyEmptyString ;
33603 wxString *arg4 = (wxString *) &arg4_defvalue ;
33604 wxMenuItem *result;
33605 bool temp3 = false ;
33606 bool temp4 = false ;
33607 PyObject * obj0 = 0 ;
33608 PyObject * obj1 = 0 ;
33609 PyObject * obj2 = 0 ;
33610 PyObject * obj3 = 0 ;
33611 char *kwnames[] = {
33612 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33613 };
33614
33615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33617 if (SWIG_arg_fail(1)) SWIG_fail;
33618 {
33619 arg2 = static_cast<int >(SWIG_As_int(obj1));
33620 if (SWIG_arg_fail(2)) SWIG_fail;
33621 }
33622 {
33623 arg3 = wxString_in_helper(obj2);
33624 if (arg3 == NULL) SWIG_fail;
33625 temp3 = true;
33626 }
33627 if (obj3) {
33628 {
33629 arg4 = wxString_in_helper(obj3);
33630 if (arg4 == NULL) SWIG_fail;
33631 temp4 = true;
33632 }
33633 }
33634 {
33635 PyThreadState* __tstate = wxPyBeginAllowThreads();
33636 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33637
33638 wxPyEndAllowThreads(__tstate);
33639 if (PyErr_Occurred()) SWIG_fail;
33640 }
33641 {
33642 resultobj = wxPyMake_wxObject(result, (bool)0);
33643 }
33644 {
33645 if (temp3)
33646 delete arg3;
33647 }
33648 {
33649 if (temp4)
33650 delete arg4;
33651 }
33652 return resultobj;
33653 fail:
33654 {
33655 if (temp3)
33656 delete arg3;
33657 }
33658 {
33659 if (temp4)
33660 delete arg4;
33661 }
33662 return NULL;
33663 }
33664
33665
33666 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33667 PyObject *resultobj = NULL;
33668 wxMenu *arg1 = (wxMenu *) 0 ;
33669 int arg2 ;
33670 wxString *arg3 = 0 ;
33671 wxString const &arg4_defvalue = wxPyEmptyString ;
33672 wxString *arg4 = (wxString *) &arg4_defvalue ;
33673 wxMenuItem *result;
33674 bool temp3 = false ;
33675 bool temp4 = false ;
33676 PyObject * obj0 = 0 ;
33677 PyObject * obj1 = 0 ;
33678 PyObject * obj2 = 0 ;
33679 PyObject * obj3 = 0 ;
33680 char *kwnames[] = {
33681 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33682 };
33683
33684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33686 if (SWIG_arg_fail(1)) SWIG_fail;
33687 {
33688 arg2 = static_cast<int >(SWIG_As_int(obj1));
33689 if (SWIG_arg_fail(2)) SWIG_fail;
33690 }
33691 {
33692 arg3 = wxString_in_helper(obj2);
33693 if (arg3 == NULL) SWIG_fail;
33694 temp3 = true;
33695 }
33696 if (obj3) {
33697 {
33698 arg4 = wxString_in_helper(obj3);
33699 if (arg4 == NULL) SWIG_fail;
33700 temp4 = true;
33701 }
33702 }
33703 {
33704 PyThreadState* __tstate = wxPyBeginAllowThreads();
33705 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33706
33707 wxPyEndAllowThreads(__tstate);
33708 if (PyErr_Occurred()) SWIG_fail;
33709 }
33710 {
33711 resultobj = wxPyMake_wxObject(result, (bool)0);
33712 }
33713 {
33714 if (temp3)
33715 delete arg3;
33716 }
33717 {
33718 if (temp4)
33719 delete arg4;
33720 }
33721 return resultobj;
33722 fail:
33723 {
33724 if (temp3)
33725 delete arg3;
33726 }
33727 {
33728 if (temp4)
33729 delete arg4;
33730 }
33731 return NULL;
33732 }
33733
33734
33735 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33736 PyObject *resultobj = NULL;
33737 wxMenu *arg1 = (wxMenu *) 0 ;
33738 int arg2 ;
33739 wxString *arg3 = 0 ;
33740 wxMenu *arg4 = (wxMenu *) 0 ;
33741 wxString const &arg5_defvalue = wxPyEmptyString ;
33742 wxString *arg5 = (wxString *) &arg5_defvalue ;
33743 wxMenuItem *result;
33744 bool temp3 = false ;
33745 bool temp5 = false ;
33746 PyObject * obj0 = 0 ;
33747 PyObject * obj1 = 0 ;
33748 PyObject * obj2 = 0 ;
33749 PyObject * obj3 = 0 ;
33750 PyObject * obj4 = 0 ;
33751 char *kwnames[] = {
33752 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33753 };
33754
33755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33757 if (SWIG_arg_fail(1)) SWIG_fail;
33758 {
33759 arg2 = static_cast<int >(SWIG_As_int(obj1));
33760 if (SWIG_arg_fail(2)) SWIG_fail;
33761 }
33762 {
33763 arg3 = wxString_in_helper(obj2);
33764 if (arg3 == NULL) SWIG_fail;
33765 temp3 = true;
33766 }
33767 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33768 if (SWIG_arg_fail(4)) SWIG_fail;
33769 if (obj4) {
33770 {
33771 arg5 = wxString_in_helper(obj4);
33772 if (arg5 == NULL) SWIG_fail;
33773 temp5 = true;
33774 }
33775 }
33776 {
33777 PyThreadState* __tstate = wxPyBeginAllowThreads();
33778 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33779
33780 wxPyEndAllowThreads(__tstate);
33781 if (PyErr_Occurred()) SWIG_fail;
33782 }
33783 {
33784 resultobj = wxPyMake_wxObject(result, (bool)0);
33785 }
33786 {
33787 if (temp3)
33788 delete arg3;
33789 }
33790 {
33791 if (temp5)
33792 delete arg5;
33793 }
33794 return resultobj;
33795 fail:
33796 {
33797 if (temp3)
33798 delete arg3;
33799 }
33800 {
33801 if (temp5)
33802 delete arg5;
33803 }
33804 return NULL;
33805 }
33806
33807
33808 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33809 PyObject *resultobj = NULL;
33810 wxMenu *arg1 = (wxMenu *) 0 ;
33811 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33812 wxMenuItem *result;
33813 PyObject * obj0 = 0 ;
33814 PyObject * obj1 = 0 ;
33815 char *kwnames[] = {
33816 (char *) "self",(char *) "item", NULL
33817 };
33818
33819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33821 if (SWIG_arg_fail(1)) SWIG_fail;
33822 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33823 if (SWIG_arg_fail(2)) SWIG_fail;
33824 {
33825 PyThreadState* __tstate = wxPyBeginAllowThreads();
33826 result = (wxMenuItem *)(arg1)->Append(arg2);
33827
33828 wxPyEndAllowThreads(__tstate);
33829 if (PyErr_Occurred()) SWIG_fail;
33830 }
33831 {
33832 resultobj = wxPyMake_wxObject(result, (bool)0);
33833 }
33834 return resultobj;
33835 fail:
33836 return NULL;
33837 }
33838
33839
33840 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33841 PyObject *resultobj = NULL;
33842 wxMenu *arg1 = (wxMenu *) 0 ;
33843 PyObject * obj0 = 0 ;
33844 char *kwnames[] = {
33845 (char *) "self", NULL
33846 };
33847
33848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33850 if (SWIG_arg_fail(1)) SWIG_fail;
33851 {
33852 PyThreadState* __tstate = wxPyBeginAllowThreads();
33853 (arg1)->Break();
33854
33855 wxPyEndAllowThreads(__tstate);
33856 if (PyErr_Occurred()) SWIG_fail;
33857 }
33858 Py_INCREF(Py_None); resultobj = Py_None;
33859 return resultobj;
33860 fail:
33861 return NULL;
33862 }
33863
33864
33865 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33866 PyObject *resultobj = NULL;
33867 wxMenu *arg1 = (wxMenu *) 0 ;
33868 size_t arg2 ;
33869 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33870 wxMenuItem *result;
33871 PyObject * obj0 = 0 ;
33872 PyObject * obj1 = 0 ;
33873 PyObject * obj2 = 0 ;
33874 char *kwnames[] = {
33875 (char *) "self",(char *) "pos",(char *) "item", NULL
33876 };
33877
33878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33880 if (SWIG_arg_fail(1)) SWIG_fail;
33881 {
33882 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
33883 if (SWIG_arg_fail(2)) SWIG_fail;
33884 }
33885 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33886 if (SWIG_arg_fail(3)) SWIG_fail;
33887 {
33888 PyThreadState* __tstate = wxPyBeginAllowThreads();
33889 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33890
33891 wxPyEndAllowThreads(__tstate);
33892 if (PyErr_Occurred()) SWIG_fail;
33893 }
33894 {
33895 resultobj = wxPyMake_wxObject(result, (bool)0);
33896 }
33897 return resultobj;
33898 fail:
33899 return NULL;
33900 }
33901
33902
33903 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33904 PyObject *resultobj = NULL;
33905 wxMenu *arg1 = (wxMenu *) 0 ;
33906 size_t arg2 ;
33907 int arg3 ;
33908 wxString *arg4 = 0 ;
33909 wxString const &arg5_defvalue = wxPyEmptyString ;
33910 wxString *arg5 = (wxString *) &arg5_defvalue ;
33911 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33912 wxMenuItem *result;
33913 bool temp4 = false ;
33914 bool temp5 = false ;
33915 PyObject * obj0 = 0 ;
33916 PyObject * obj1 = 0 ;
33917 PyObject * obj2 = 0 ;
33918 PyObject * obj3 = 0 ;
33919 PyObject * obj4 = 0 ;
33920 PyObject * obj5 = 0 ;
33921 char *kwnames[] = {
33922 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33923 };
33924
33925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33927 if (SWIG_arg_fail(1)) SWIG_fail;
33928 {
33929 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
33930 if (SWIG_arg_fail(2)) SWIG_fail;
33931 }
33932 {
33933 arg3 = static_cast<int >(SWIG_As_int(obj2));
33934 if (SWIG_arg_fail(3)) SWIG_fail;
33935 }
33936 {
33937 arg4 = wxString_in_helper(obj3);
33938 if (arg4 == NULL) SWIG_fail;
33939 temp4 = true;
33940 }
33941 if (obj4) {
33942 {
33943 arg5 = wxString_in_helper(obj4);
33944 if (arg5 == NULL) SWIG_fail;
33945 temp5 = true;
33946 }
33947 }
33948 if (obj5) {
33949 {
33950 arg6 = static_cast<wxItemKind >(SWIG_As_int(obj5));
33951 if (SWIG_arg_fail(6)) SWIG_fail;
33952 }
33953 }
33954 {
33955 PyThreadState* __tstate = wxPyBeginAllowThreads();
33956 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
33957
33958 wxPyEndAllowThreads(__tstate);
33959 if (PyErr_Occurred()) SWIG_fail;
33960 }
33961 {
33962 resultobj = wxPyMake_wxObject(result, (bool)0);
33963 }
33964 {
33965 if (temp4)
33966 delete arg4;
33967 }
33968 {
33969 if (temp5)
33970 delete arg5;
33971 }
33972 return resultobj;
33973 fail:
33974 {
33975 if (temp4)
33976 delete arg4;
33977 }
33978 {
33979 if (temp5)
33980 delete arg5;
33981 }
33982 return NULL;
33983 }
33984
33985
33986 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33987 PyObject *resultobj = NULL;
33988 wxMenu *arg1 = (wxMenu *) 0 ;
33989 size_t arg2 ;
33990 wxMenuItem *result;
33991 PyObject * obj0 = 0 ;
33992 PyObject * obj1 = 0 ;
33993 char *kwnames[] = {
33994 (char *) "self",(char *) "pos", NULL
33995 };
33996
33997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33999 if (SWIG_arg_fail(1)) SWIG_fail;
34000 {
34001 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34002 if (SWIG_arg_fail(2)) SWIG_fail;
34003 }
34004 {
34005 PyThreadState* __tstate = wxPyBeginAllowThreads();
34006 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
34007
34008 wxPyEndAllowThreads(__tstate);
34009 if (PyErr_Occurred()) SWIG_fail;
34010 }
34011 {
34012 resultobj = wxPyMake_wxObject(result, (bool)0);
34013 }
34014 return resultobj;
34015 fail:
34016 return NULL;
34017 }
34018
34019
34020 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34021 PyObject *resultobj = NULL;
34022 wxMenu *arg1 = (wxMenu *) 0 ;
34023 size_t arg2 ;
34024 int arg3 ;
34025 wxString *arg4 = 0 ;
34026 wxString const &arg5_defvalue = wxPyEmptyString ;
34027 wxString *arg5 = (wxString *) &arg5_defvalue ;
34028 wxMenuItem *result;
34029 bool temp4 = false ;
34030 bool temp5 = false ;
34031 PyObject * obj0 = 0 ;
34032 PyObject * obj1 = 0 ;
34033 PyObject * obj2 = 0 ;
34034 PyObject * obj3 = 0 ;
34035 PyObject * obj4 = 0 ;
34036 char *kwnames[] = {
34037 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
34038 };
34039
34040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34042 if (SWIG_arg_fail(1)) SWIG_fail;
34043 {
34044 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34045 if (SWIG_arg_fail(2)) SWIG_fail;
34046 }
34047 {
34048 arg3 = static_cast<int >(SWIG_As_int(obj2));
34049 if (SWIG_arg_fail(3)) SWIG_fail;
34050 }
34051 {
34052 arg4 = wxString_in_helper(obj3);
34053 if (arg4 == NULL) SWIG_fail;
34054 temp4 = true;
34055 }
34056 if (obj4) {
34057 {
34058 arg5 = wxString_in_helper(obj4);
34059 if (arg5 == NULL) SWIG_fail;
34060 temp5 = true;
34061 }
34062 }
34063 {
34064 PyThreadState* __tstate = wxPyBeginAllowThreads();
34065 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
34066
34067 wxPyEndAllowThreads(__tstate);
34068 if (PyErr_Occurred()) SWIG_fail;
34069 }
34070 {
34071 resultobj = wxPyMake_wxObject(result, (bool)0);
34072 }
34073 {
34074 if (temp4)
34075 delete arg4;
34076 }
34077 {
34078 if (temp5)
34079 delete arg5;
34080 }
34081 return resultobj;
34082 fail:
34083 {
34084 if (temp4)
34085 delete arg4;
34086 }
34087 {
34088 if (temp5)
34089 delete arg5;
34090 }
34091 return NULL;
34092 }
34093
34094
34095 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34096 PyObject *resultobj = NULL;
34097 wxMenu *arg1 = (wxMenu *) 0 ;
34098 size_t arg2 ;
34099 int arg3 ;
34100 wxString *arg4 = 0 ;
34101 wxString const &arg5_defvalue = wxPyEmptyString ;
34102 wxString *arg5 = (wxString *) &arg5_defvalue ;
34103 wxMenuItem *result;
34104 bool temp4 = false ;
34105 bool temp5 = false ;
34106 PyObject * obj0 = 0 ;
34107 PyObject * obj1 = 0 ;
34108 PyObject * obj2 = 0 ;
34109 PyObject * obj3 = 0 ;
34110 PyObject * obj4 = 0 ;
34111 char *kwnames[] = {
34112 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
34113 };
34114
34115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34117 if (SWIG_arg_fail(1)) SWIG_fail;
34118 {
34119 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34120 if (SWIG_arg_fail(2)) SWIG_fail;
34121 }
34122 {
34123 arg3 = static_cast<int >(SWIG_As_int(obj2));
34124 if (SWIG_arg_fail(3)) SWIG_fail;
34125 }
34126 {
34127 arg4 = wxString_in_helper(obj3);
34128 if (arg4 == NULL) SWIG_fail;
34129 temp4 = true;
34130 }
34131 if (obj4) {
34132 {
34133 arg5 = wxString_in_helper(obj4);
34134 if (arg5 == NULL) SWIG_fail;
34135 temp5 = true;
34136 }
34137 }
34138 {
34139 PyThreadState* __tstate = wxPyBeginAllowThreads();
34140 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
34141
34142 wxPyEndAllowThreads(__tstate);
34143 if (PyErr_Occurred()) SWIG_fail;
34144 }
34145 {
34146 resultobj = wxPyMake_wxObject(result, (bool)0);
34147 }
34148 {
34149 if (temp4)
34150 delete arg4;
34151 }
34152 {
34153 if (temp5)
34154 delete arg5;
34155 }
34156 return resultobj;
34157 fail:
34158 {
34159 if (temp4)
34160 delete arg4;
34161 }
34162 {
34163 if (temp5)
34164 delete arg5;
34165 }
34166 return NULL;
34167 }
34168
34169
34170 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34171 PyObject *resultobj = NULL;
34172 wxMenu *arg1 = (wxMenu *) 0 ;
34173 size_t arg2 ;
34174 int arg3 ;
34175 wxString *arg4 = 0 ;
34176 wxMenu *arg5 = (wxMenu *) 0 ;
34177 wxString const &arg6_defvalue = wxPyEmptyString ;
34178 wxString *arg6 = (wxString *) &arg6_defvalue ;
34179 wxMenuItem *result;
34180 bool temp4 = false ;
34181 bool temp6 = false ;
34182 PyObject * obj0 = 0 ;
34183 PyObject * obj1 = 0 ;
34184 PyObject * obj2 = 0 ;
34185 PyObject * obj3 = 0 ;
34186 PyObject * obj4 = 0 ;
34187 PyObject * obj5 = 0 ;
34188 char *kwnames[] = {
34189 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34190 };
34191
34192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
34193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34194 if (SWIG_arg_fail(1)) SWIG_fail;
34195 {
34196 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34197 if (SWIG_arg_fail(2)) SWIG_fail;
34198 }
34199 {
34200 arg3 = static_cast<int >(SWIG_As_int(obj2));
34201 if (SWIG_arg_fail(3)) SWIG_fail;
34202 }
34203 {
34204 arg4 = wxString_in_helper(obj3);
34205 if (arg4 == NULL) SWIG_fail;
34206 temp4 = true;
34207 }
34208 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34209 if (SWIG_arg_fail(5)) SWIG_fail;
34210 if (obj5) {
34211 {
34212 arg6 = wxString_in_helper(obj5);
34213 if (arg6 == NULL) SWIG_fail;
34214 temp6 = true;
34215 }
34216 }
34217 {
34218 PyThreadState* __tstate = wxPyBeginAllowThreads();
34219 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
34220
34221 wxPyEndAllowThreads(__tstate);
34222 if (PyErr_Occurred()) SWIG_fail;
34223 }
34224 {
34225 resultobj = wxPyMake_wxObject(result, (bool)0);
34226 }
34227 {
34228 if (temp4)
34229 delete arg4;
34230 }
34231 {
34232 if (temp6)
34233 delete arg6;
34234 }
34235 return resultobj;
34236 fail:
34237 {
34238 if (temp4)
34239 delete arg4;
34240 }
34241 {
34242 if (temp6)
34243 delete arg6;
34244 }
34245 return NULL;
34246 }
34247
34248
34249 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
34250 PyObject *resultobj = NULL;
34251 wxMenu *arg1 = (wxMenu *) 0 ;
34252 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34253 wxMenuItem *result;
34254 PyObject * obj0 = 0 ;
34255 PyObject * obj1 = 0 ;
34256 char *kwnames[] = {
34257 (char *) "self",(char *) "item", NULL
34258 };
34259
34260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
34261 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34262 if (SWIG_arg_fail(1)) SWIG_fail;
34263 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34264 if (SWIG_arg_fail(2)) SWIG_fail;
34265 {
34266 PyThreadState* __tstate = wxPyBeginAllowThreads();
34267 result = (wxMenuItem *)(arg1)->Prepend(arg2);
34268
34269 wxPyEndAllowThreads(__tstate);
34270 if (PyErr_Occurred()) SWIG_fail;
34271 }
34272 {
34273 resultobj = wxPyMake_wxObject(result, (bool)0);
34274 }
34275 return resultobj;
34276 fail:
34277 return NULL;
34278 }
34279
34280
34281 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
34282 PyObject *resultobj = NULL;
34283 wxMenu *arg1 = (wxMenu *) 0 ;
34284 int arg2 ;
34285 wxString *arg3 = 0 ;
34286 wxString const &arg4_defvalue = wxPyEmptyString ;
34287 wxString *arg4 = (wxString *) &arg4_defvalue ;
34288 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
34289 wxMenuItem *result;
34290 bool temp3 = false ;
34291 bool temp4 = false ;
34292 PyObject * obj0 = 0 ;
34293 PyObject * obj1 = 0 ;
34294 PyObject * obj2 = 0 ;
34295 PyObject * obj3 = 0 ;
34296 PyObject * obj4 = 0 ;
34297 char *kwnames[] = {
34298 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
34299 };
34300
34301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34303 if (SWIG_arg_fail(1)) SWIG_fail;
34304 {
34305 arg2 = static_cast<int >(SWIG_As_int(obj1));
34306 if (SWIG_arg_fail(2)) SWIG_fail;
34307 }
34308 {
34309 arg3 = wxString_in_helper(obj2);
34310 if (arg3 == NULL) SWIG_fail;
34311 temp3 = true;
34312 }
34313 if (obj3) {
34314 {
34315 arg4 = wxString_in_helper(obj3);
34316 if (arg4 == NULL) SWIG_fail;
34317 temp4 = true;
34318 }
34319 }
34320 if (obj4) {
34321 {
34322 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
34323 if (SWIG_arg_fail(5)) SWIG_fail;
34324 }
34325 }
34326 {
34327 PyThreadState* __tstate = wxPyBeginAllowThreads();
34328 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
34329
34330 wxPyEndAllowThreads(__tstate);
34331 if (PyErr_Occurred()) SWIG_fail;
34332 }
34333 {
34334 resultobj = wxPyMake_wxObject(result, (bool)0);
34335 }
34336 {
34337 if (temp3)
34338 delete arg3;
34339 }
34340 {
34341 if (temp4)
34342 delete arg4;
34343 }
34344 return resultobj;
34345 fail:
34346 {
34347 if (temp3)
34348 delete arg3;
34349 }
34350 {
34351 if (temp4)
34352 delete arg4;
34353 }
34354 return NULL;
34355 }
34356
34357
34358 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
34359 PyObject *resultobj = NULL;
34360 wxMenu *arg1 = (wxMenu *) 0 ;
34361 wxMenuItem *result;
34362 PyObject * obj0 = 0 ;
34363 char *kwnames[] = {
34364 (char *) "self", NULL
34365 };
34366
34367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
34368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34369 if (SWIG_arg_fail(1)) SWIG_fail;
34370 {
34371 PyThreadState* __tstate = wxPyBeginAllowThreads();
34372 result = (wxMenuItem *)(arg1)->PrependSeparator();
34373
34374 wxPyEndAllowThreads(__tstate);
34375 if (PyErr_Occurred()) SWIG_fail;
34376 }
34377 {
34378 resultobj = wxPyMake_wxObject(result, (bool)0);
34379 }
34380 return resultobj;
34381 fail:
34382 return NULL;
34383 }
34384
34385
34386 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34387 PyObject *resultobj = NULL;
34388 wxMenu *arg1 = (wxMenu *) 0 ;
34389 int arg2 ;
34390 wxString *arg3 = 0 ;
34391 wxString const &arg4_defvalue = wxPyEmptyString ;
34392 wxString *arg4 = (wxString *) &arg4_defvalue ;
34393 wxMenuItem *result;
34394 bool temp3 = false ;
34395 bool temp4 = false ;
34396 PyObject * obj0 = 0 ;
34397 PyObject * obj1 = 0 ;
34398 PyObject * obj2 = 0 ;
34399 PyObject * obj3 = 0 ;
34400 char *kwnames[] = {
34401 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34402 };
34403
34404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34406 if (SWIG_arg_fail(1)) SWIG_fail;
34407 {
34408 arg2 = static_cast<int >(SWIG_As_int(obj1));
34409 if (SWIG_arg_fail(2)) SWIG_fail;
34410 }
34411 {
34412 arg3 = wxString_in_helper(obj2);
34413 if (arg3 == NULL) SWIG_fail;
34414 temp3 = true;
34415 }
34416 if (obj3) {
34417 {
34418 arg4 = wxString_in_helper(obj3);
34419 if (arg4 == NULL) SWIG_fail;
34420 temp4 = true;
34421 }
34422 }
34423 {
34424 PyThreadState* __tstate = wxPyBeginAllowThreads();
34425 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34426
34427 wxPyEndAllowThreads(__tstate);
34428 if (PyErr_Occurred()) SWIG_fail;
34429 }
34430 {
34431 resultobj = wxPyMake_wxObject(result, (bool)0);
34432 }
34433 {
34434 if (temp3)
34435 delete arg3;
34436 }
34437 {
34438 if (temp4)
34439 delete arg4;
34440 }
34441 return resultobj;
34442 fail:
34443 {
34444 if (temp3)
34445 delete arg3;
34446 }
34447 {
34448 if (temp4)
34449 delete arg4;
34450 }
34451 return NULL;
34452 }
34453
34454
34455 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34456 PyObject *resultobj = NULL;
34457 wxMenu *arg1 = (wxMenu *) 0 ;
34458 int arg2 ;
34459 wxString *arg3 = 0 ;
34460 wxString const &arg4_defvalue = wxPyEmptyString ;
34461 wxString *arg4 = (wxString *) &arg4_defvalue ;
34462 wxMenuItem *result;
34463 bool temp3 = false ;
34464 bool temp4 = false ;
34465 PyObject * obj0 = 0 ;
34466 PyObject * obj1 = 0 ;
34467 PyObject * obj2 = 0 ;
34468 PyObject * obj3 = 0 ;
34469 char *kwnames[] = {
34470 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34471 };
34472
34473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34475 if (SWIG_arg_fail(1)) SWIG_fail;
34476 {
34477 arg2 = static_cast<int >(SWIG_As_int(obj1));
34478 if (SWIG_arg_fail(2)) SWIG_fail;
34479 }
34480 {
34481 arg3 = wxString_in_helper(obj2);
34482 if (arg3 == NULL) SWIG_fail;
34483 temp3 = true;
34484 }
34485 if (obj3) {
34486 {
34487 arg4 = wxString_in_helper(obj3);
34488 if (arg4 == NULL) SWIG_fail;
34489 temp4 = true;
34490 }
34491 }
34492 {
34493 PyThreadState* __tstate = wxPyBeginAllowThreads();
34494 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34495
34496 wxPyEndAllowThreads(__tstate);
34497 if (PyErr_Occurred()) SWIG_fail;
34498 }
34499 {
34500 resultobj = wxPyMake_wxObject(result, (bool)0);
34501 }
34502 {
34503 if (temp3)
34504 delete arg3;
34505 }
34506 {
34507 if (temp4)
34508 delete arg4;
34509 }
34510 return resultobj;
34511 fail:
34512 {
34513 if (temp3)
34514 delete arg3;
34515 }
34516 {
34517 if (temp4)
34518 delete arg4;
34519 }
34520 return NULL;
34521 }
34522
34523
34524 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34525 PyObject *resultobj = NULL;
34526 wxMenu *arg1 = (wxMenu *) 0 ;
34527 int arg2 ;
34528 wxString *arg3 = 0 ;
34529 wxMenu *arg4 = (wxMenu *) 0 ;
34530 wxString const &arg5_defvalue = wxPyEmptyString ;
34531 wxString *arg5 = (wxString *) &arg5_defvalue ;
34532 wxMenuItem *result;
34533 bool temp3 = false ;
34534 bool temp5 = false ;
34535 PyObject * obj0 = 0 ;
34536 PyObject * obj1 = 0 ;
34537 PyObject * obj2 = 0 ;
34538 PyObject * obj3 = 0 ;
34539 PyObject * obj4 = 0 ;
34540 char *kwnames[] = {
34541 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34542 };
34543
34544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34546 if (SWIG_arg_fail(1)) SWIG_fail;
34547 {
34548 arg2 = static_cast<int >(SWIG_As_int(obj1));
34549 if (SWIG_arg_fail(2)) SWIG_fail;
34550 }
34551 {
34552 arg3 = wxString_in_helper(obj2);
34553 if (arg3 == NULL) SWIG_fail;
34554 temp3 = true;
34555 }
34556 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34557 if (SWIG_arg_fail(4)) SWIG_fail;
34558 if (obj4) {
34559 {
34560 arg5 = wxString_in_helper(obj4);
34561 if (arg5 == NULL) SWIG_fail;
34562 temp5 = true;
34563 }
34564 }
34565 {
34566 PyThreadState* __tstate = wxPyBeginAllowThreads();
34567 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
34568
34569 wxPyEndAllowThreads(__tstate);
34570 if (PyErr_Occurred()) SWIG_fail;
34571 }
34572 {
34573 resultobj = wxPyMake_wxObject(result, (bool)0);
34574 }
34575 {
34576 if (temp3)
34577 delete arg3;
34578 }
34579 {
34580 if (temp5)
34581 delete arg5;
34582 }
34583 return resultobj;
34584 fail:
34585 {
34586 if (temp3)
34587 delete arg3;
34588 }
34589 {
34590 if (temp5)
34591 delete arg5;
34592 }
34593 return NULL;
34594 }
34595
34596
34597 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34598 PyObject *resultobj = NULL;
34599 wxMenu *arg1 = (wxMenu *) 0 ;
34600 int arg2 ;
34601 wxMenuItem *result;
34602 PyObject * obj0 = 0 ;
34603 PyObject * obj1 = 0 ;
34604 char *kwnames[] = {
34605 (char *) "self",(char *) "id", NULL
34606 };
34607
34608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
34609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34610 if (SWIG_arg_fail(1)) SWIG_fail;
34611 {
34612 arg2 = static_cast<int >(SWIG_As_int(obj1));
34613 if (SWIG_arg_fail(2)) SWIG_fail;
34614 }
34615 {
34616 PyThreadState* __tstate = wxPyBeginAllowThreads();
34617 result = (wxMenuItem *)(arg1)->Remove(arg2);
34618
34619 wxPyEndAllowThreads(__tstate);
34620 if (PyErr_Occurred()) SWIG_fail;
34621 }
34622 {
34623 resultobj = wxPyMake_wxObject(result, (bool)0);
34624 }
34625 return resultobj;
34626 fail:
34627 return NULL;
34628 }
34629
34630
34631 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
34632 PyObject *resultobj = NULL;
34633 wxMenu *arg1 = (wxMenu *) 0 ;
34634 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34635 wxMenuItem *result;
34636 PyObject * obj0 = 0 ;
34637 PyObject * obj1 = 0 ;
34638 char *kwnames[] = {
34639 (char *) "self",(char *) "item", NULL
34640 };
34641
34642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
34643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34644 if (SWIG_arg_fail(1)) SWIG_fail;
34645 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34646 if (SWIG_arg_fail(2)) SWIG_fail;
34647 {
34648 PyThreadState* __tstate = wxPyBeginAllowThreads();
34649 result = (wxMenuItem *)(arg1)->Remove(arg2);
34650
34651 wxPyEndAllowThreads(__tstate);
34652 if (PyErr_Occurred()) SWIG_fail;
34653 }
34654 {
34655 resultobj = wxPyMake_wxObject(result, (bool)0);
34656 }
34657 return resultobj;
34658 fail:
34659 return NULL;
34660 }
34661
34662
34663 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
34664 PyObject *resultobj = NULL;
34665 wxMenu *arg1 = (wxMenu *) 0 ;
34666 int arg2 ;
34667 bool result;
34668 PyObject * obj0 = 0 ;
34669 PyObject * obj1 = 0 ;
34670 char *kwnames[] = {
34671 (char *) "self",(char *) "id", NULL
34672 };
34673
34674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
34675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34676 if (SWIG_arg_fail(1)) SWIG_fail;
34677 {
34678 arg2 = static_cast<int >(SWIG_As_int(obj1));
34679 if (SWIG_arg_fail(2)) SWIG_fail;
34680 }
34681 {
34682 PyThreadState* __tstate = wxPyBeginAllowThreads();
34683 result = (bool)(arg1)->Delete(arg2);
34684
34685 wxPyEndAllowThreads(__tstate);
34686 if (PyErr_Occurred()) SWIG_fail;
34687 }
34688 {
34689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34690 }
34691 return resultobj;
34692 fail:
34693 return NULL;
34694 }
34695
34696
34697 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
34698 PyObject *resultobj = NULL;
34699 wxMenu *arg1 = (wxMenu *) 0 ;
34700 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34701 bool result;
34702 PyObject * obj0 = 0 ;
34703 PyObject * obj1 = 0 ;
34704 char *kwnames[] = {
34705 (char *) "self",(char *) "item", NULL
34706 };
34707
34708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
34709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34710 if (SWIG_arg_fail(1)) SWIG_fail;
34711 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34712 if (SWIG_arg_fail(2)) SWIG_fail;
34713 {
34714 PyThreadState* __tstate = wxPyBeginAllowThreads();
34715 result = (bool)(arg1)->Delete(arg2);
34716
34717 wxPyEndAllowThreads(__tstate);
34718 if (PyErr_Occurred()) SWIG_fail;
34719 }
34720 {
34721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34722 }
34723 return resultobj;
34724 fail:
34725 return NULL;
34726 }
34727
34728
34729 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
34730 PyObject *resultobj = NULL;
34731 wxMenu *arg1 = (wxMenu *) 0 ;
34732 PyObject * obj0 = 0 ;
34733 char *kwnames[] = {
34734 (char *) "self", NULL
34735 };
34736
34737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
34738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34739 if (SWIG_arg_fail(1)) SWIG_fail;
34740 {
34741 PyThreadState* __tstate = wxPyBeginAllowThreads();
34742 wxMenu_Destroy(arg1);
34743
34744 wxPyEndAllowThreads(__tstate);
34745 if (PyErr_Occurred()) SWIG_fail;
34746 }
34747 Py_INCREF(Py_None); resultobj = Py_None;
34748 return resultobj;
34749 fail:
34750 return NULL;
34751 }
34752
34753
34754 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
34755 PyObject *resultobj = NULL;
34756 wxMenu *arg1 = (wxMenu *) 0 ;
34757 int arg2 ;
34758 bool result;
34759 PyObject * obj0 = 0 ;
34760 PyObject * obj1 = 0 ;
34761 char *kwnames[] = {
34762 (char *) "self",(char *) "id", NULL
34763 };
34764
34765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
34766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34767 if (SWIG_arg_fail(1)) SWIG_fail;
34768 {
34769 arg2 = static_cast<int >(SWIG_As_int(obj1));
34770 if (SWIG_arg_fail(2)) SWIG_fail;
34771 }
34772 {
34773 PyThreadState* __tstate = wxPyBeginAllowThreads();
34774 result = (bool)(arg1)->Destroy(arg2);
34775
34776 wxPyEndAllowThreads(__tstate);
34777 if (PyErr_Occurred()) SWIG_fail;
34778 }
34779 {
34780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34781 }
34782 return resultobj;
34783 fail:
34784 return NULL;
34785 }
34786
34787
34788 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34789 PyObject *resultobj = NULL;
34790 wxMenu *arg1 = (wxMenu *) 0 ;
34791 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34792 bool result;
34793 PyObject * obj0 = 0 ;
34794 PyObject * obj1 = 0 ;
34795 char *kwnames[] = {
34796 (char *) "self",(char *) "item", NULL
34797 };
34798
34799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34801 if (SWIG_arg_fail(1)) SWIG_fail;
34802 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34803 if (SWIG_arg_fail(2)) SWIG_fail;
34804 {
34805 PyThreadState* __tstate = wxPyBeginAllowThreads();
34806 result = (bool)(arg1)->Destroy(arg2);
34807
34808 wxPyEndAllowThreads(__tstate);
34809 if (PyErr_Occurred()) SWIG_fail;
34810 }
34811 {
34812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34813 }
34814 return resultobj;
34815 fail:
34816 return NULL;
34817 }
34818
34819
34820 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34821 PyObject *resultobj = NULL;
34822 wxMenu *arg1 = (wxMenu *) 0 ;
34823 size_t result;
34824 PyObject * obj0 = 0 ;
34825 char *kwnames[] = {
34826 (char *) "self", NULL
34827 };
34828
34829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34831 if (SWIG_arg_fail(1)) SWIG_fail;
34832 {
34833 PyThreadState* __tstate = wxPyBeginAllowThreads();
34834 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34835
34836 wxPyEndAllowThreads(__tstate);
34837 if (PyErr_Occurred()) SWIG_fail;
34838 }
34839 {
34840 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
34841 }
34842 return resultobj;
34843 fail:
34844 return NULL;
34845 }
34846
34847
34848 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34849 PyObject *resultobj = NULL;
34850 wxMenu *arg1 = (wxMenu *) 0 ;
34851 PyObject *result;
34852 PyObject * obj0 = 0 ;
34853 char *kwnames[] = {
34854 (char *) "self", NULL
34855 };
34856
34857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34859 if (SWIG_arg_fail(1)) SWIG_fail;
34860 {
34861 PyThreadState* __tstate = wxPyBeginAllowThreads();
34862 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34863
34864 wxPyEndAllowThreads(__tstate);
34865 if (PyErr_Occurred()) SWIG_fail;
34866 }
34867 resultobj = result;
34868 return resultobj;
34869 fail:
34870 return NULL;
34871 }
34872
34873
34874 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34875 PyObject *resultobj = NULL;
34876 wxMenu *arg1 = (wxMenu *) 0 ;
34877 wxString *arg2 = 0 ;
34878 int result;
34879 bool temp2 = false ;
34880 PyObject * obj0 = 0 ;
34881 PyObject * obj1 = 0 ;
34882 char *kwnames[] = {
34883 (char *) "self",(char *) "item", NULL
34884 };
34885
34886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34888 if (SWIG_arg_fail(1)) SWIG_fail;
34889 {
34890 arg2 = wxString_in_helper(obj1);
34891 if (arg2 == NULL) SWIG_fail;
34892 temp2 = true;
34893 }
34894 {
34895 PyThreadState* __tstate = wxPyBeginAllowThreads();
34896 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34897
34898 wxPyEndAllowThreads(__tstate);
34899 if (PyErr_Occurred()) SWIG_fail;
34900 }
34901 {
34902 resultobj = SWIG_From_int(static_cast<int >(result));
34903 }
34904 {
34905 if (temp2)
34906 delete arg2;
34907 }
34908 return resultobj;
34909 fail:
34910 {
34911 if (temp2)
34912 delete arg2;
34913 }
34914 return NULL;
34915 }
34916
34917
34918 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34919 PyObject *resultobj = NULL;
34920 wxMenu *arg1 = (wxMenu *) 0 ;
34921 int arg2 ;
34922 wxMenuItem *result;
34923 PyObject * obj0 = 0 ;
34924 PyObject * obj1 = 0 ;
34925 char *kwnames[] = {
34926 (char *) "self",(char *) "id", NULL
34927 };
34928
34929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34931 if (SWIG_arg_fail(1)) SWIG_fail;
34932 {
34933 arg2 = static_cast<int >(SWIG_As_int(obj1));
34934 if (SWIG_arg_fail(2)) SWIG_fail;
34935 }
34936 {
34937 PyThreadState* __tstate = wxPyBeginAllowThreads();
34938 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34939
34940 wxPyEndAllowThreads(__tstate);
34941 if (PyErr_Occurred()) SWIG_fail;
34942 }
34943 {
34944 resultobj = wxPyMake_wxObject(result, (bool)0);
34945 }
34946 return resultobj;
34947 fail:
34948 return NULL;
34949 }
34950
34951
34952 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34953 PyObject *resultobj = NULL;
34954 wxMenu *arg1 = (wxMenu *) 0 ;
34955 size_t arg2 ;
34956 wxMenuItem *result;
34957 PyObject * obj0 = 0 ;
34958 PyObject * obj1 = 0 ;
34959 char *kwnames[] = {
34960 (char *) "self",(char *) "position", NULL
34961 };
34962
34963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34965 if (SWIG_arg_fail(1)) SWIG_fail;
34966 {
34967 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34968 if (SWIG_arg_fail(2)) SWIG_fail;
34969 }
34970 {
34971 PyThreadState* __tstate = wxPyBeginAllowThreads();
34972 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34973
34974 wxPyEndAllowThreads(__tstate);
34975 if (PyErr_Occurred()) SWIG_fail;
34976 }
34977 {
34978 resultobj = wxPyMake_wxObject(result, (bool)0);
34979 }
34980 return resultobj;
34981 fail:
34982 return NULL;
34983 }
34984
34985
34986 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34987 PyObject *resultobj = NULL;
34988 wxMenu *arg1 = (wxMenu *) 0 ;
34989 int arg2 ;
34990 bool arg3 ;
34991 PyObject * obj0 = 0 ;
34992 PyObject * obj1 = 0 ;
34993 PyObject * obj2 = 0 ;
34994 char *kwnames[] = {
34995 (char *) "self",(char *) "id",(char *) "enable", NULL
34996 };
34997
34998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35000 if (SWIG_arg_fail(1)) SWIG_fail;
35001 {
35002 arg2 = static_cast<int >(SWIG_As_int(obj1));
35003 if (SWIG_arg_fail(2)) SWIG_fail;
35004 }
35005 {
35006 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
35007 if (SWIG_arg_fail(3)) SWIG_fail;
35008 }
35009 {
35010 PyThreadState* __tstate = wxPyBeginAllowThreads();
35011 (arg1)->Enable(arg2,arg3);
35012
35013 wxPyEndAllowThreads(__tstate);
35014 if (PyErr_Occurred()) SWIG_fail;
35015 }
35016 Py_INCREF(Py_None); resultobj = Py_None;
35017 return resultobj;
35018 fail:
35019 return NULL;
35020 }
35021
35022
35023 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35024 PyObject *resultobj = NULL;
35025 wxMenu *arg1 = (wxMenu *) 0 ;
35026 int arg2 ;
35027 bool result;
35028 PyObject * obj0 = 0 ;
35029 PyObject * obj1 = 0 ;
35030 char *kwnames[] = {
35031 (char *) "self",(char *) "id", NULL
35032 };
35033
35034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35036 if (SWIG_arg_fail(1)) SWIG_fail;
35037 {
35038 arg2 = static_cast<int >(SWIG_As_int(obj1));
35039 if (SWIG_arg_fail(2)) SWIG_fail;
35040 }
35041 {
35042 PyThreadState* __tstate = wxPyBeginAllowThreads();
35043 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
35044
35045 wxPyEndAllowThreads(__tstate);
35046 if (PyErr_Occurred()) SWIG_fail;
35047 }
35048 {
35049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35050 }
35051 return resultobj;
35052 fail:
35053 return NULL;
35054 }
35055
35056
35057 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35058 PyObject *resultobj = NULL;
35059 wxMenu *arg1 = (wxMenu *) 0 ;
35060 int arg2 ;
35061 bool arg3 ;
35062 PyObject * obj0 = 0 ;
35063 PyObject * obj1 = 0 ;
35064 PyObject * obj2 = 0 ;
35065 char *kwnames[] = {
35066 (char *) "self",(char *) "id",(char *) "check", NULL
35067 };
35068
35069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35071 if (SWIG_arg_fail(1)) SWIG_fail;
35072 {
35073 arg2 = static_cast<int >(SWIG_As_int(obj1));
35074 if (SWIG_arg_fail(2)) SWIG_fail;
35075 }
35076 {
35077 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
35078 if (SWIG_arg_fail(3)) SWIG_fail;
35079 }
35080 {
35081 PyThreadState* __tstate = wxPyBeginAllowThreads();
35082 (arg1)->Check(arg2,arg3);
35083
35084 wxPyEndAllowThreads(__tstate);
35085 if (PyErr_Occurred()) SWIG_fail;
35086 }
35087 Py_INCREF(Py_None); resultobj = Py_None;
35088 return resultobj;
35089 fail:
35090 return NULL;
35091 }
35092
35093
35094 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35095 PyObject *resultobj = NULL;
35096 wxMenu *arg1 = (wxMenu *) 0 ;
35097 int arg2 ;
35098 bool result;
35099 PyObject * obj0 = 0 ;
35100 PyObject * obj1 = 0 ;
35101 char *kwnames[] = {
35102 (char *) "self",(char *) "id", NULL
35103 };
35104
35105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35107 if (SWIG_arg_fail(1)) SWIG_fail;
35108 {
35109 arg2 = static_cast<int >(SWIG_As_int(obj1));
35110 if (SWIG_arg_fail(2)) SWIG_fail;
35111 }
35112 {
35113 PyThreadState* __tstate = wxPyBeginAllowThreads();
35114 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
35115
35116 wxPyEndAllowThreads(__tstate);
35117 if (PyErr_Occurred()) SWIG_fail;
35118 }
35119 {
35120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35121 }
35122 return resultobj;
35123 fail:
35124 return NULL;
35125 }
35126
35127
35128 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35129 PyObject *resultobj = NULL;
35130 wxMenu *arg1 = (wxMenu *) 0 ;
35131 int arg2 ;
35132 wxString *arg3 = 0 ;
35133 bool temp3 = false ;
35134 PyObject * obj0 = 0 ;
35135 PyObject * obj1 = 0 ;
35136 PyObject * obj2 = 0 ;
35137 char *kwnames[] = {
35138 (char *) "self",(char *) "id",(char *) "label", NULL
35139 };
35140
35141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35143 if (SWIG_arg_fail(1)) SWIG_fail;
35144 {
35145 arg2 = static_cast<int >(SWIG_As_int(obj1));
35146 if (SWIG_arg_fail(2)) SWIG_fail;
35147 }
35148 {
35149 arg3 = wxString_in_helper(obj2);
35150 if (arg3 == NULL) SWIG_fail;
35151 temp3 = true;
35152 }
35153 {
35154 PyThreadState* __tstate = wxPyBeginAllowThreads();
35155 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35156
35157 wxPyEndAllowThreads(__tstate);
35158 if (PyErr_Occurred()) SWIG_fail;
35159 }
35160 Py_INCREF(Py_None); resultobj = Py_None;
35161 {
35162 if (temp3)
35163 delete arg3;
35164 }
35165 return resultobj;
35166 fail:
35167 {
35168 if (temp3)
35169 delete arg3;
35170 }
35171 return NULL;
35172 }
35173
35174
35175 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35176 PyObject *resultobj = NULL;
35177 wxMenu *arg1 = (wxMenu *) 0 ;
35178 int arg2 ;
35179 wxString result;
35180 PyObject * obj0 = 0 ;
35181 PyObject * obj1 = 0 ;
35182 char *kwnames[] = {
35183 (char *) "self",(char *) "id", NULL
35184 };
35185
35186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35188 if (SWIG_arg_fail(1)) SWIG_fail;
35189 {
35190 arg2 = static_cast<int >(SWIG_As_int(obj1));
35191 if (SWIG_arg_fail(2)) SWIG_fail;
35192 }
35193 {
35194 PyThreadState* __tstate = wxPyBeginAllowThreads();
35195 result = ((wxMenu const *)arg1)->GetLabel(arg2);
35196
35197 wxPyEndAllowThreads(__tstate);
35198 if (PyErr_Occurred()) SWIG_fail;
35199 }
35200 {
35201 #if wxUSE_UNICODE
35202 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35203 #else
35204 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35205 #endif
35206 }
35207 return resultobj;
35208 fail:
35209 return NULL;
35210 }
35211
35212
35213 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35214 PyObject *resultobj = NULL;
35215 wxMenu *arg1 = (wxMenu *) 0 ;
35216 int arg2 ;
35217 wxString *arg3 = 0 ;
35218 bool temp3 = false ;
35219 PyObject * obj0 = 0 ;
35220 PyObject * obj1 = 0 ;
35221 PyObject * obj2 = 0 ;
35222 char *kwnames[] = {
35223 (char *) "self",(char *) "id",(char *) "helpString", NULL
35224 };
35225
35226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35228 if (SWIG_arg_fail(1)) SWIG_fail;
35229 {
35230 arg2 = static_cast<int >(SWIG_As_int(obj1));
35231 if (SWIG_arg_fail(2)) SWIG_fail;
35232 }
35233 {
35234 arg3 = wxString_in_helper(obj2);
35235 if (arg3 == NULL) SWIG_fail;
35236 temp3 = true;
35237 }
35238 {
35239 PyThreadState* __tstate = wxPyBeginAllowThreads();
35240 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35241
35242 wxPyEndAllowThreads(__tstate);
35243 if (PyErr_Occurred()) SWIG_fail;
35244 }
35245 Py_INCREF(Py_None); resultobj = Py_None;
35246 {
35247 if (temp3)
35248 delete arg3;
35249 }
35250 return resultobj;
35251 fail:
35252 {
35253 if (temp3)
35254 delete arg3;
35255 }
35256 return NULL;
35257 }
35258
35259
35260 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35261 PyObject *resultobj = NULL;
35262 wxMenu *arg1 = (wxMenu *) 0 ;
35263 int arg2 ;
35264 wxString result;
35265 PyObject * obj0 = 0 ;
35266 PyObject * obj1 = 0 ;
35267 char *kwnames[] = {
35268 (char *) "self",(char *) "id", NULL
35269 };
35270
35271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35273 if (SWIG_arg_fail(1)) SWIG_fail;
35274 {
35275 arg2 = static_cast<int >(SWIG_As_int(obj1));
35276 if (SWIG_arg_fail(2)) SWIG_fail;
35277 }
35278 {
35279 PyThreadState* __tstate = wxPyBeginAllowThreads();
35280 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
35281
35282 wxPyEndAllowThreads(__tstate);
35283 if (PyErr_Occurred()) SWIG_fail;
35284 }
35285 {
35286 #if wxUSE_UNICODE
35287 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35288 #else
35289 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35290 #endif
35291 }
35292 return resultobj;
35293 fail:
35294 return NULL;
35295 }
35296
35297
35298 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35299 PyObject *resultobj = NULL;
35300 wxMenu *arg1 = (wxMenu *) 0 ;
35301 wxString *arg2 = 0 ;
35302 bool temp2 = false ;
35303 PyObject * obj0 = 0 ;
35304 PyObject * obj1 = 0 ;
35305 char *kwnames[] = {
35306 (char *) "self",(char *) "title", NULL
35307 };
35308
35309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
35310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35311 if (SWIG_arg_fail(1)) SWIG_fail;
35312 {
35313 arg2 = wxString_in_helper(obj1);
35314 if (arg2 == NULL) SWIG_fail;
35315 temp2 = true;
35316 }
35317 {
35318 PyThreadState* __tstate = wxPyBeginAllowThreads();
35319 (arg1)->SetTitle((wxString const &)*arg2);
35320
35321 wxPyEndAllowThreads(__tstate);
35322 if (PyErr_Occurred()) SWIG_fail;
35323 }
35324 Py_INCREF(Py_None); resultobj = Py_None;
35325 {
35326 if (temp2)
35327 delete arg2;
35328 }
35329 return resultobj;
35330 fail:
35331 {
35332 if (temp2)
35333 delete arg2;
35334 }
35335 return NULL;
35336 }
35337
35338
35339 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35340 PyObject *resultobj = NULL;
35341 wxMenu *arg1 = (wxMenu *) 0 ;
35342 wxString result;
35343 PyObject * obj0 = 0 ;
35344 char *kwnames[] = {
35345 (char *) "self", NULL
35346 };
35347
35348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
35349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35350 if (SWIG_arg_fail(1)) SWIG_fail;
35351 {
35352 PyThreadState* __tstate = wxPyBeginAllowThreads();
35353 result = ((wxMenu const *)arg1)->GetTitle();
35354
35355 wxPyEndAllowThreads(__tstate);
35356 if (PyErr_Occurred()) SWIG_fail;
35357 }
35358 {
35359 #if wxUSE_UNICODE
35360 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35361 #else
35362 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35363 #endif
35364 }
35365 return resultobj;
35366 fail:
35367 return NULL;
35368 }
35369
35370
35371 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35372 PyObject *resultobj = NULL;
35373 wxMenu *arg1 = (wxMenu *) 0 ;
35374 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
35375 PyObject * obj0 = 0 ;
35376 PyObject * obj1 = 0 ;
35377 char *kwnames[] = {
35378 (char *) "self",(char *) "handler", NULL
35379 };
35380
35381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
35382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35383 if (SWIG_arg_fail(1)) SWIG_fail;
35384 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35385 if (SWIG_arg_fail(2)) SWIG_fail;
35386 {
35387 PyThreadState* __tstate = wxPyBeginAllowThreads();
35388 (arg1)->SetEventHandler(arg2);
35389
35390 wxPyEndAllowThreads(__tstate);
35391 if (PyErr_Occurred()) SWIG_fail;
35392 }
35393 Py_INCREF(Py_None); resultobj = Py_None;
35394 return resultobj;
35395 fail:
35396 return NULL;
35397 }
35398
35399
35400 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35401 PyObject *resultobj = NULL;
35402 wxMenu *arg1 = (wxMenu *) 0 ;
35403 wxEvtHandler *result;
35404 PyObject * obj0 = 0 ;
35405 char *kwnames[] = {
35406 (char *) "self", NULL
35407 };
35408
35409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
35410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35411 if (SWIG_arg_fail(1)) SWIG_fail;
35412 {
35413 PyThreadState* __tstate = wxPyBeginAllowThreads();
35414 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
35415
35416 wxPyEndAllowThreads(__tstate);
35417 if (PyErr_Occurred()) SWIG_fail;
35418 }
35419 {
35420 resultobj = wxPyMake_wxObject(result, 0);
35421 }
35422 return resultobj;
35423 fail:
35424 return NULL;
35425 }
35426
35427
35428 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35429 PyObject *resultobj = NULL;
35430 wxMenu *arg1 = (wxMenu *) 0 ;
35431 wxWindow *arg2 = (wxWindow *) 0 ;
35432 PyObject * obj0 = 0 ;
35433 PyObject * obj1 = 0 ;
35434 char *kwnames[] = {
35435 (char *) "self",(char *) "win", NULL
35436 };
35437
35438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
35439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35440 if (SWIG_arg_fail(1)) SWIG_fail;
35441 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
35442 if (SWIG_arg_fail(2)) SWIG_fail;
35443 {
35444 PyThreadState* __tstate = wxPyBeginAllowThreads();
35445 (arg1)->SetInvokingWindow(arg2);
35446
35447 wxPyEndAllowThreads(__tstate);
35448 if (PyErr_Occurred()) SWIG_fail;
35449 }
35450 Py_INCREF(Py_None); resultobj = Py_None;
35451 return resultobj;
35452 fail:
35453 return NULL;
35454 }
35455
35456
35457 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35458 PyObject *resultobj = NULL;
35459 wxMenu *arg1 = (wxMenu *) 0 ;
35460 wxWindow *result;
35461 PyObject * obj0 = 0 ;
35462 char *kwnames[] = {
35463 (char *) "self", NULL
35464 };
35465
35466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
35467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35468 if (SWIG_arg_fail(1)) SWIG_fail;
35469 {
35470 PyThreadState* __tstate = wxPyBeginAllowThreads();
35471 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
35472
35473 wxPyEndAllowThreads(__tstate);
35474 if (PyErr_Occurred()) SWIG_fail;
35475 }
35476 {
35477 resultobj = wxPyMake_wxObject(result, 0);
35478 }
35479 return resultobj;
35480 fail:
35481 return NULL;
35482 }
35483
35484
35485 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
35486 PyObject *resultobj = NULL;
35487 wxMenu *arg1 = (wxMenu *) 0 ;
35488 long result;
35489 PyObject * obj0 = 0 ;
35490 char *kwnames[] = {
35491 (char *) "self", NULL
35492 };
35493
35494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
35495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35496 if (SWIG_arg_fail(1)) SWIG_fail;
35497 {
35498 PyThreadState* __tstate = wxPyBeginAllowThreads();
35499 result = (long)((wxMenu const *)arg1)->GetStyle();
35500
35501 wxPyEndAllowThreads(__tstate);
35502 if (PyErr_Occurred()) SWIG_fail;
35503 }
35504 {
35505 resultobj = SWIG_From_long(static_cast<long >(result));
35506 }
35507 return resultobj;
35508 fail:
35509 return NULL;
35510 }
35511
35512
35513 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
35514 PyObject *resultobj = NULL;
35515 wxMenu *arg1 = (wxMenu *) 0 ;
35516 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
35517 PyObject * obj0 = 0 ;
35518 PyObject * obj1 = 0 ;
35519 char *kwnames[] = {
35520 (char *) "self",(char *) "source", NULL
35521 };
35522
35523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
35524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35525 if (SWIG_arg_fail(1)) SWIG_fail;
35526 if (obj1) {
35527 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35528 if (SWIG_arg_fail(2)) SWIG_fail;
35529 }
35530 {
35531 PyThreadState* __tstate = wxPyBeginAllowThreads();
35532 (arg1)->UpdateUI(arg2);
35533
35534 wxPyEndAllowThreads(__tstate);
35535 if (PyErr_Occurred()) SWIG_fail;
35536 }
35537 Py_INCREF(Py_None); resultobj = Py_None;
35538 return resultobj;
35539 fail:
35540 return NULL;
35541 }
35542
35543
35544 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35545 PyObject *resultobj = NULL;
35546 wxMenu *arg1 = (wxMenu *) 0 ;
35547 wxMenuBar *result;
35548 PyObject * obj0 = 0 ;
35549 char *kwnames[] = {
35550 (char *) "self", NULL
35551 };
35552
35553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
35554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35555 if (SWIG_arg_fail(1)) SWIG_fail;
35556 {
35557 PyThreadState* __tstate = wxPyBeginAllowThreads();
35558 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
35559
35560 wxPyEndAllowThreads(__tstate);
35561 if (PyErr_Occurred()) SWIG_fail;
35562 }
35563 {
35564 resultobj = wxPyMake_wxObject(result, (bool)0);
35565 }
35566 return resultobj;
35567 fail:
35568 return NULL;
35569 }
35570
35571
35572 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35573 PyObject *resultobj = NULL;
35574 wxMenu *arg1 = (wxMenu *) 0 ;
35575 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
35576 PyObject * obj0 = 0 ;
35577 PyObject * obj1 = 0 ;
35578 char *kwnames[] = {
35579 (char *) "self",(char *) "menubar", NULL
35580 };
35581
35582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
35583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35584 if (SWIG_arg_fail(1)) SWIG_fail;
35585 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
35586 if (SWIG_arg_fail(2)) SWIG_fail;
35587 {
35588 PyThreadState* __tstate = wxPyBeginAllowThreads();
35589 (arg1)->Attach(arg2);
35590
35591 wxPyEndAllowThreads(__tstate);
35592 if (PyErr_Occurred()) SWIG_fail;
35593 }
35594 Py_INCREF(Py_None); resultobj = Py_None;
35595 return resultobj;
35596 fail:
35597 return NULL;
35598 }
35599
35600
35601 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35602 PyObject *resultobj = NULL;
35603 wxMenu *arg1 = (wxMenu *) 0 ;
35604 PyObject * obj0 = 0 ;
35605 char *kwnames[] = {
35606 (char *) "self", NULL
35607 };
35608
35609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
35610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35611 if (SWIG_arg_fail(1)) SWIG_fail;
35612 {
35613 PyThreadState* __tstate = wxPyBeginAllowThreads();
35614 (arg1)->Detach();
35615
35616 wxPyEndAllowThreads(__tstate);
35617 if (PyErr_Occurred()) SWIG_fail;
35618 }
35619 Py_INCREF(Py_None); resultobj = Py_None;
35620 return resultobj;
35621 fail:
35622 return NULL;
35623 }
35624
35625
35626 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35627 PyObject *resultobj = NULL;
35628 wxMenu *arg1 = (wxMenu *) 0 ;
35629 bool result;
35630 PyObject * obj0 = 0 ;
35631 char *kwnames[] = {
35632 (char *) "self", NULL
35633 };
35634
35635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
35636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35637 if (SWIG_arg_fail(1)) SWIG_fail;
35638 {
35639 PyThreadState* __tstate = wxPyBeginAllowThreads();
35640 result = (bool)((wxMenu const *)arg1)->IsAttached();
35641
35642 wxPyEndAllowThreads(__tstate);
35643 if (PyErr_Occurred()) SWIG_fail;
35644 }
35645 {
35646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35647 }
35648 return resultobj;
35649 fail:
35650 return NULL;
35651 }
35652
35653
35654 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35655 PyObject *resultobj = NULL;
35656 wxMenu *arg1 = (wxMenu *) 0 ;
35657 wxMenu *arg2 = (wxMenu *) 0 ;
35658 PyObject * obj0 = 0 ;
35659 PyObject * obj1 = 0 ;
35660 char *kwnames[] = {
35661 (char *) "self",(char *) "parent", NULL
35662 };
35663
35664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
35665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35666 if (SWIG_arg_fail(1)) SWIG_fail;
35667 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35668 if (SWIG_arg_fail(2)) SWIG_fail;
35669 {
35670 PyThreadState* __tstate = wxPyBeginAllowThreads();
35671 (arg1)->SetParent(arg2);
35672
35673 wxPyEndAllowThreads(__tstate);
35674 if (PyErr_Occurred()) SWIG_fail;
35675 }
35676 Py_INCREF(Py_None); resultobj = Py_None;
35677 return resultobj;
35678 fail:
35679 return NULL;
35680 }
35681
35682
35683 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35684 PyObject *resultobj = NULL;
35685 wxMenu *arg1 = (wxMenu *) 0 ;
35686 wxMenu *result;
35687 PyObject * obj0 = 0 ;
35688 char *kwnames[] = {
35689 (char *) "self", NULL
35690 };
35691
35692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
35693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35694 if (SWIG_arg_fail(1)) SWIG_fail;
35695 {
35696 PyThreadState* __tstate = wxPyBeginAllowThreads();
35697 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
35698
35699 wxPyEndAllowThreads(__tstate);
35700 if (PyErr_Occurred()) SWIG_fail;
35701 }
35702 {
35703 resultobj = wxPyMake_wxObject(result, 0);
35704 }
35705 return resultobj;
35706 fail:
35707 return NULL;
35708 }
35709
35710
35711 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
35712 PyObject *obj;
35713 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35714 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
35715 Py_INCREF(obj);
35716 return Py_BuildValue((char *)"");
35717 }
35718 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35719 PyObject *resultobj = NULL;
35720 long arg1 = (long) 0 ;
35721 wxMenuBar *result;
35722 PyObject * obj0 = 0 ;
35723 char *kwnames[] = {
35724 (char *) "style", NULL
35725 };
35726
35727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
35728 if (obj0) {
35729 {
35730 arg1 = static_cast<long >(SWIG_As_long(obj0));
35731 if (SWIG_arg_fail(1)) SWIG_fail;
35732 }
35733 }
35734 {
35735 if (!wxPyCheckForApp()) SWIG_fail;
35736 PyThreadState* __tstate = wxPyBeginAllowThreads();
35737 result = (wxMenuBar *)new wxMenuBar(arg1);
35738
35739 wxPyEndAllowThreads(__tstate);
35740 if (PyErr_Occurred()) SWIG_fail;
35741 }
35742 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
35743 return resultobj;
35744 fail:
35745 return NULL;
35746 }
35747
35748
35749 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
35750 PyObject *resultobj = NULL;
35751 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35752 wxMenu *arg2 = (wxMenu *) 0 ;
35753 wxString *arg3 = 0 ;
35754 bool result;
35755 bool temp3 = false ;
35756 PyObject * obj0 = 0 ;
35757 PyObject * obj1 = 0 ;
35758 PyObject * obj2 = 0 ;
35759 char *kwnames[] = {
35760 (char *) "self",(char *) "menu",(char *) "title", NULL
35761 };
35762
35763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
35764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35765 if (SWIG_arg_fail(1)) SWIG_fail;
35766 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35767 if (SWIG_arg_fail(2)) SWIG_fail;
35768 {
35769 arg3 = wxString_in_helper(obj2);
35770 if (arg3 == NULL) SWIG_fail;
35771 temp3 = true;
35772 }
35773 {
35774 PyThreadState* __tstate = wxPyBeginAllowThreads();
35775 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
35776
35777 wxPyEndAllowThreads(__tstate);
35778 if (PyErr_Occurred()) SWIG_fail;
35779 }
35780 {
35781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35782 }
35783 {
35784 if (temp3)
35785 delete arg3;
35786 }
35787 return resultobj;
35788 fail:
35789 {
35790 if (temp3)
35791 delete arg3;
35792 }
35793 return NULL;
35794 }
35795
35796
35797 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35798 PyObject *resultobj = NULL;
35799 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35800 size_t arg2 ;
35801 wxMenu *arg3 = (wxMenu *) 0 ;
35802 wxString *arg4 = 0 ;
35803 bool result;
35804 bool temp4 = false ;
35805 PyObject * obj0 = 0 ;
35806 PyObject * obj1 = 0 ;
35807 PyObject * obj2 = 0 ;
35808 PyObject * obj3 = 0 ;
35809 char *kwnames[] = {
35810 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35811 };
35812
35813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35815 if (SWIG_arg_fail(1)) SWIG_fail;
35816 {
35817 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35818 if (SWIG_arg_fail(2)) SWIG_fail;
35819 }
35820 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35821 if (SWIG_arg_fail(3)) SWIG_fail;
35822 {
35823 arg4 = wxString_in_helper(obj3);
35824 if (arg4 == NULL) SWIG_fail;
35825 temp4 = true;
35826 }
35827 {
35828 PyThreadState* __tstate = wxPyBeginAllowThreads();
35829 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35830
35831 wxPyEndAllowThreads(__tstate);
35832 if (PyErr_Occurred()) SWIG_fail;
35833 }
35834 {
35835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35836 }
35837 {
35838 if (temp4)
35839 delete arg4;
35840 }
35841 return resultobj;
35842 fail:
35843 {
35844 if (temp4)
35845 delete arg4;
35846 }
35847 return NULL;
35848 }
35849
35850
35851 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35852 PyObject *resultobj = NULL;
35853 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35854 size_t result;
35855 PyObject * obj0 = 0 ;
35856 char *kwnames[] = {
35857 (char *) "self", NULL
35858 };
35859
35860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35862 if (SWIG_arg_fail(1)) SWIG_fail;
35863 {
35864 PyThreadState* __tstate = wxPyBeginAllowThreads();
35865 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35866
35867 wxPyEndAllowThreads(__tstate);
35868 if (PyErr_Occurred()) SWIG_fail;
35869 }
35870 {
35871 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
35872 }
35873 return resultobj;
35874 fail:
35875 return NULL;
35876 }
35877
35878
35879 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35880 PyObject *resultobj = NULL;
35881 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35882 size_t arg2 ;
35883 wxMenu *result;
35884 PyObject * obj0 = 0 ;
35885 PyObject * obj1 = 0 ;
35886 char *kwnames[] = {
35887 (char *) "self",(char *) "pos", NULL
35888 };
35889
35890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35892 if (SWIG_arg_fail(1)) SWIG_fail;
35893 {
35894 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35895 if (SWIG_arg_fail(2)) SWIG_fail;
35896 }
35897 {
35898 PyThreadState* __tstate = wxPyBeginAllowThreads();
35899 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35900
35901 wxPyEndAllowThreads(__tstate);
35902 if (PyErr_Occurred()) SWIG_fail;
35903 }
35904 {
35905 resultobj = wxPyMake_wxObject(result, 0);
35906 }
35907 return resultobj;
35908 fail:
35909 return NULL;
35910 }
35911
35912
35913 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35914 PyObject *resultobj = NULL;
35915 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35916 size_t arg2 ;
35917 wxMenu *arg3 = (wxMenu *) 0 ;
35918 wxString *arg4 = 0 ;
35919 wxMenu *result;
35920 bool temp4 = false ;
35921 PyObject * obj0 = 0 ;
35922 PyObject * obj1 = 0 ;
35923 PyObject * obj2 = 0 ;
35924 PyObject * obj3 = 0 ;
35925 char *kwnames[] = {
35926 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35927 };
35928
35929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35931 if (SWIG_arg_fail(1)) SWIG_fail;
35932 {
35933 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35934 if (SWIG_arg_fail(2)) SWIG_fail;
35935 }
35936 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35937 if (SWIG_arg_fail(3)) SWIG_fail;
35938 {
35939 arg4 = wxString_in_helper(obj3);
35940 if (arg4 == NULL) SWIG_fail;
35941 temp4 = true;
35942 }
35943 {
35944 PyThreadState* __tstate = wxPyBeginAllowThreads();
35945 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35946
35947 wxPyEndAllowThreads(__tstate);
35948 if (PyErr_Occurred()) SWIG_fail;
35949 }
35950 {
35951 resultobj = wxPyMake_wxObject(result, 0);
35952 }
35953 {
35954 if (temp4)
35955 delete arg4;
35956 }
35957 return resultobj;
35958 fail:
35959 {
35960 if (temp4)
35961 delete arg4;
35962 }
35963 return NULL;
35964 }
35965
35966
35967 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35968 PyObject *resultobj = NULL;
35969 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35970 size_t arg2 ;
35971 wxMenu *result;
35972 PyObject * obj0 = 0 ;
35973 PyObject * obj1 = 0 ;
35974 char *kwnames[] = {
35975 (char *) "self",(char *) "pos", NULL
35976 };
35977
35978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35980 if (SWIG_arg_fail(1)) SWIG_fail;
35981 {
35982 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35983 if (SWIG_arg_fail(2)) SWIG_fail;
35984 }
35985 {
35986 PyThreadState* __tstate = wxPyBeginAllowThreads();
35987 result = (wxMenu *)(arg1)->Remove(arg2);
35988
35989 wxPyEndAllowThreads(__tstate);
35990 if (PyErr_Occurred()) SWIG_fail;
35991 }
35992 {
35993 resultobj = wxPyMake_wxObject(result, 0);
35994 }
35995 return resultobj;
35996 fail:
35997 return NULL;
35998 }
35999
36000
36001 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
36002 PyObject *resultobj = NULL;
36003 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36004 size_t arg2 ;
36005 bool arg3 ;
36006 PyObject * obj0 = 0 ;
36007 PyObject * obj1 = 0 ;
36008 PyObject * obj2 = 0 ;
36009 char *kwnames[] = {
36010 (char *) "self",(char *) "pos",(char *) "enable", NULL
36011 };
36012
36013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
36014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36015 if (SWIG_arg_fail(1)) SWIG_fail;
36016 {
36017 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36018 if (SWIG_arg_fail(2)) SWIG_fail;
36019 }
36020 {
36021 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36022 if (SWIG_arg_fail(3)) SWIG_fail;
36023 }
36024 {
36025 PyThreadState* __tstate = wxPyBeginAllowThreads();
36026 (arg1)->EnableTop(arg2,arg3);
36027
36028 wxPyEndAllowThreads(__tstate);
36029 if (PyErr_Occurred()) SWIG_fail;
36030 }
36031 Py_INCREF(Py_None); resultobj = Py_None;
36032 return resultobj;
36033 fail:
36034 return NULL;
36035 }
36036
36037
36038 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
36039 PyObject *resultobj = NULL;
36040 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36041 size_t arg2 ;
36042 bool result;
36043 PyObject * obj0 = 0 ;
36044 PyObject * obj1 = 0 ;
36045 char *kwnames[] = {
36046 (char *) "self",(char *) "pos", NULL
36047 };
36048
36049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
36050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36051 if (SWIG_arg_fail(1)) SWIG_fail;
36052 {
36053 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36054 if (SWIG_arg_fail(2)) SWIG_fail;
36055 }
36056 {
36057 PyThreadState* __tstate = wxPyBeginAllowThreads();
36058 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
36059
36060 wxPyEndAllowThreads(__tstate);
36061 if (PyErr_Occurred()) SWIG_fail;
36062 }
36063 {
36064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36065 }
36066 return resultobj;
36067 fail:
36068 return NULL;
36069 }
36070
36071
36072 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
36073 PyObject *resultobj = NULL;
36074 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36075 size_t arg2 ;
36076 wxString *arg3 = 0 ;
36077 bool temp3 = false ;
36078 PyObject * obj0 = 0 ;
36079 PyObject * obj1 = 0 ;
36080 PyObject * obj2 = 0 ;
36081 char *kwnames[] = {
36082 (char *) "self",(char *) "pos",(char *) "label", NULL
36083 };
36084
36085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
36086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36087 if (SWIG_arg_fail(1)) SWIG_fail;
36088 {
36089 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36090 if (SWIG_arg_fail(2)) SWIG_fail;
36091 }
36092 {
36093 arg3 = wxString_in_helper(obj2);
36094 if (arg3 == NULL) SWIG_fail;
36095 temp3 = true;
36096 }
36097 {
36098 PyThreadState* __tstate = wxPyBeginAllowThreads();
36099 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
36100
36101 wxPyEndAllowThreads(__tstate);
36102 if (PyErr_Occurred()) SWIG_fail;
36103 }
36104 Py_INCREF(Py_None); resultobj = Py_None;
36105 {
36106 if (temp3)
36107 delete arg3;
36108 }
36109 return resultobj;
36110 fail:
36111 {
36112 if (temp3)
36113 delete arg3;
36114 }
36115 return NULL;
36116 }
36117
36118
36119 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
36120 PyObject *resultobj = NULL;
36121 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36122 size_t arg2 ;
36123 wxString result;
36124 PyObject * obj0 = 0 ;
36125 PyObject * obj1 = 0 ;
36126 char *kwnames[] = {
36127 (char *) "self",(char *) "pos", NULL
36128 };
36129
36130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
36131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36132 if (SWIG_arg_fail(1)) SWIG_fail;
36133 {
36134 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36135 if (SWIG_arg_fail(2)) SWIG_fail;
36136 }
36137 {
36138 PyThreadState* __tstate = wxPyBeginAllowThreads();
36139 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
36140
36141 wxPyEndAllowThreads(__tstate);
36142 if (PyErr_Occurred()) SWIG_fail;
36143 }
36144 {
36145 #if wxUSE_UNICODE
36146 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36147 #else
36148 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36149 #endif
36150 }
36151 return resultobj;
36152 fail:
36153 return NULL;
36154 }
36155
36156
36157 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36158 PyObject *resultobj = NULL;
36159 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36160 wxString *arg2 = 0 ;
36161 wxString *arg3 = 0 ;
36162 int result;
36163 bool temp2 = false ;
36164 bool temp3 = false ;
36165 PyObject * obj0 = 0 ;
36166 PyObject * obj1 = 0 ;
36167 PyObject * obj2 = 0 ;
36168 char *kwnames[] = {
36169 (char *) "self",(char *) "menu",(char *) "item", NULL
36170 };
36171
36172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
36173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36174 if (SWIG_arg_fail(1)) SWIG_fail;
36175 {
36176 arg2 = wxString_in_helper(obj1);
36177 if (arg2 == NULL) SWIG_fail;
36178 temp2 = true;
36179 }
36180 {
36181 arg3 = wxString_in_helper(obj2);
36182 if (arg3 == NULL) SWIG_fail;
36183 temp3 = true;
36184 }
36185 {
36186 PyThreadState* __tstate = wxPyBeginAllowThreads();
36187 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
36188
36189 wxPyEndAllowThreads(__tstate);
36190 if (PyErr_Occurred()) SWIG_fail;
36191 }
36192 {
36193 resultobj = SWIG_From_int(static_cast<int >(result));
36194 }
36195 {
36196 if (temp2)
36197 delete arg2;
36198 }
36199 {
36200 if (temp3)
36201 delete arg3;
36202 }
36203 return resultobj;
36204 fail:
36205 {
36206 if (temp2)
36207 delete arg2;
36208 }
36209 {
36210 if (temp3)
36211 delete arg3;
36212 }
36213 return NULL;
36214 }
36215
36216
36217 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
36218 PyObject *resultobj = NULL;
36219 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36220 int arg2 ;
36221 wxMenuItem *result;
36222 PyObject * obj0 = 0 ;
36223 PyObject * obj1 = 0 ;
36224 char *kwnames[] = {
36225 (char *) "self",(char *) "id", NULL
36226 };
36227
36228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
36229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36230 if (SWIG_arg_fail(1)) SWIG_fail;
36231 {
36232 arg2 = static_cast<int >(SWIG_As_int(obj1));
36233 if (SWIG_arg_fail(2)) SWIG_fail;
36234 }
36235 {
36236 PyThreadState* __tstate = wxPyBeginAllowThreads();
36237 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
36238
36239 wxPyEndAllowThreads(__tstate);
36240 if (PyErr_Occurred()) SWIG_fail;
36241 }
36242 {
36243 resultobj = wxPyMake_wxObject(result, (bool)0);
36244 }
36245 return resultobj;
36246 fail:
36247 return NULL;
36248 }
36249
36250
36251 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36252 PyObject *resultobj = NULL;
36253 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36254 wxString *arg2 = 0 ;
36255 int result;
36256 bool temp2 = false ;
36257 PyObject * obj0 = 0 ;
36258 PyObject * obj1 = 0 ;
36259 char *kwnames[] = {
36260 (char *) "self",(char *) "title", NULL
36261 };
36262
36263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
36264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36265 if (SWIG_arg_fail(1)) SWIG_fail;
36266 {
36267 arg2 = wxString_in_helper(obj1);
36268 if (arg2 == NULL) SWIG_fail;
36269 temp2 = true;
36270 }
36271 {
36272 PyThreadState* __tstate = wxPyBeginAllowThreads();
36273 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
36274
36275 wxPyEndAllowThreads(__tstate);
36276 if (PyErr_Occurred()) SWIG_fail;
36277 }
36278 {
36279 resultobj = SWIG_From_int(static_cast<int >(result));
36280 }
36281 {
36282 if (temp2)
36283 delete arg2;
36284 }
36285 return resultobj;
36286 fail:
36287 {
36288 if (temp2)
36289 delete arg2;
36290 }
36291 return NULL;
36292 }
36293
36294
36295 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36296 PyObject *resultobj = NULL;
36297 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36298 int arg2 ;
36299 bool arg3 ;
36300 PyObject * obj0 = 0 ;
36301 PyObject * obj1 = 0 ;
36302 PyObject * obj2 = 0 ;
36303 char *kwnames[] = {
36304 (char *) "self",(char *) "id",(char *) "enable", NULL
36305 };
36306
36307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
36308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36309 if (SWIG_arg_fail(1)) SWIG_fail;
36310 {
36311 arg2 = static_cast<int >(SWIG_As_int(obj1));
36312 if (SWIG_arg_fail(2)) SWIG_fail;
36313 }
36314 {
36315 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36316 if (SWIG_arg_fail(3)) SWIG_fail;
36317 }
36318 {
36319 PyThreadState* __tstate = wxPyBeginAllowThreads();
36320 (arg1)->Enable(arg2,arg3);
36321
36322 wxPyEndAllowThreads(__tstate);
36323 if (PyErr_Occurred()) SWIG_fail;
36324 }
36325 Py_INCREF(Py_None); resultobj = Py_None;
36326 return resultobj;
36327 fail:
36328 return NULL;
36329 }
36330
36331
36332 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36333 PyObject *resultobj = NULL;
36334 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36335 int arg2 ;
36336 bool arg3 ;
36337 PyObject * obj0 = 0 ;
36338 PyObject * obj1 = 0 ;
36339 PyObject * obj2 = 0 ;
36340 char *kwnames[] = {
36341 (char *) "self",(char *) "id",(char *) "check", NULL
36342 };
36343
36344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
36345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36346 if (SWIG_arg_fail(1)) SWIG_fail;
36347 {
36348 arg2 = static_cast<int >(SWIG_As_int(obj1));
36349 if (SWIG_arg_fail(2)) SWIG_fail;
36350 }
36351 {
36352 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36353 if (SWIG_arg_fail(3)) SWIG_fail;
36354 }
36355 {
36356 PyThreadState* __tstate = wxPyBeginAllowThreads();
36357 (arg1)->Check(arg2,arg3);
36358
36359 wxPyEndAllowThreads(__tstate);
36360 if (PyErr_Occurred()) SWIG_fail;
36361 }
36362 Py_INCREF(Py_None); resultobj = Py_None;
36363 return resultobj;
36364 fail:
36365 return NULL;
36366 }
36367
36368
36369 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36370 PyObject *resultobj = NULL;
36371 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36372 int arg2 ;
36373 bool result;
36374 PyObject * obj0 = 0 ;
36375 PyObject * obj1 = 0 ;
36376 char *kwnames[] = {
36377 (char *) "self",(char *) "id", NULL
36378 };
36379
36380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
36381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36382 if (SWIG_arg_fail(1)) SWIG_fail;
36383 {
36384 arg2 = static_cast<int >(SWIG_As_int(obj1));
36385 if (SWIG_arg_fail(2)) SWIG_fail;
36386 }
36387 {
36388 PyThreadState* __tstate = wxPyBeginAllowThreads();
36389 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
36390
36391 wxPyEndAllowThreads(__tstate);
36392 if (PyErr_Occurred()) SWIG_fail;
36393 }
36394 {
36395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36396 }
36397 return resultobj;
36398 fail:
36399 return NULL;
36400 }
36401
36402
36403 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36404 PyObject *resultobj = NULL;
36405 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36406 int arg2 ;
36407 bool result;
36408 PyObject * obj0 = 0 ;
36409 PyObject * obj1 = 0 ;
36410 char *kwnames[] = {
36411 (char *) "self",(char *) "id", NULL
36412 };
36413
36414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
36415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36416 if (SWIG_arg_fail(1)) SWIG_fail;
36417 {
36418 arg2 = static_cast<int >(SWIG_As_int(obj1));
36419 if (SWIG_arg_fail(2)) SWIG_fail;
36420 }
36421 {
36422 PyThreadState* __tstate = wxPyBeginAllowThreads();
36423 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
36424
36425 wxPyEndAllowThreads(__tstate);
36426 if (PyErr_Occurred()) SWIG_fail;
36427 }
36428 {
36429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36430 }
36431 return resultobj;
36432 fail:
36433 return NULL;
36434 }
36435
36436
36437 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36438 PyObject *resultobj = NULL;
36439 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36440 int arg2 ;
36441 wxString *arg3 = 0 ;
36442 bool temp3 = false ;
36443 PyObject * obj0 = 0 ;
36444 PyObject * obj1 = 0 ;
36445 PyObject * obj2 = 0 ;
36446 char *kwnames[] = {
36447 (char *) "self",(char *) "id",(char *) "label", NULL
36448 };
36449
36450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
36451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36452 if (SWIG_arg_fail(1)) SWIG_fail;
36453 {
36454 arg2 = static_cast<int >(SWIG_As_int(obj1));
36455 if (SWIG_arg_fail(2)) SWIG_fail;
36456 }
36457 {
36458 arg3 = wxString_in_helper(obj2);
36459 if (arg3 == NULL) SWIG_fail;
36460 temp3 = true;
36461 }
36462 {
36463 PyThreadState* __tstate = wxPyBeginAllowThreads();
36464 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
36465
36466 wxPyEndAllowThreads(__tstate);
36467 if (PyErr_Occurred()) SWIG_fail;
36468 }
36469 Py_INCREF(Py_None); resultobj = Py_None;
36470 {
36471 if (temp3)
36472 delete arg3;
36473 }
36474 return resultobj;
36475 fail:
36476 {
36477 if (temp3)
36478 delete arg3;
36479 }
36480 return NULL;
36481 }
36482
36483
36484 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36485 PyObject *resultobj = NULL;
36486 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36487 int arg2 ;
36488 wxString result;
36489 PyObject * obj0 = 0 ;
36490 PyObject * obj1 = 0 ;
36491 char *kwnames[] = {
36492 (char *) "self",(char *) "id", NULL
36493 };
36494
36495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
36496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36497 if (SWIG_arg_fail(1)) SWIG_fail;
36498 {
36499 arg2 = static_cast<int >(SWIG_As_int(obj1));
36500 if (SWIG_arg_fail(2)) SWIG_fail;
36501 }
36502 {
36503 PyThreadState* __tstate = wxPyBeginAllowThreads();
36504 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
36505
36506 wxPyEndAllowThreads(__tstate);
36507 if (PyErr_Occurred()) SWIG_fail;
36508 }
36509 {
36510 #if wxUSE_UNICODE
36511 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36512 #else
36513 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36514 #endif
36515 }
36516 return resultobj;
36517 fail:
36518 return NULL;
36519 }
36520
36521
36522 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36523 PyObject *resultobj = NULL;
36524 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36525 int arg2 ;
36526 wxString *arg3 = 0 ;
36527 bool temp3 = false ;
36528 PyObject * obj0 = 0 ;
36529 PyObject * obj1 = 0 ;
36530 PyObject * obj2 = 0 ;
36531 char *kwnames[] = {
36532 (char *) "self",(char *) "id",(char *) "helpString", NULL
36533 };
36534
36535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36537 if (SWIG_arg_fail(1)) SWIG_fail;
36538 {
36539 arg2 = static_cast<int >(SWIG_As_int(obj1));
36540 if (SWIG_arg_fail(2)) SWIG_fail;
36541 }
36542 {
36543 arg3 = wxString_in_helper(obj2);
36544 if (arg3 == NULL) SWIG_fail;
36545 temp3 = true;
36546 }
36547 {
36548 PyThreadState* __tstate = wxPyBeginAllowThreads();
36549 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
36550
36551 wxPyEndAllowThreads(__tstate);
36552 if (PyErr_Occurred()) SWIG_fail;
36553 }
36554 Py_INCREF(Py_None); resultobj = Py_None;
36555 {
36556 if (temp3)
36557 delete arg3;
36558 }
36559 return resultobj;
36560 fail:
36561 {
36562 if (temp3)
36563 delete arg3;
36564 }
36565 return NULL;
36566 }
36567
36568
36569 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36570 PyObject *resultobj = NULL;
36571 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36572 int arg2 ;
36573 wxString result;
36574 PyObject * obj0 = 0 ;
36575 PyObject * obj1 = 0 ;
36576 char *kwnames[] = {
36577 (char *) "self",(char *) "id", NULL
36578 };
36579
36580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
36581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36582 if (SWIG_arg_fail(1)) SWIG_fail;
36583 {
36584 arg2 = static_cast<int >(SWIG_As_int(obj1));
36585 if (SWIG_arg_fail(2)) SWIG_fail;
36586 }
36587 {
36588 PyThreadState* __tstate = wxPyBeginAllowThreads();
36589 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
36590
36591 wxPyEndAllowThreads(__tstate);
36592 if (PyErr_Occurred()) SWIG_fail;
36593 }
36594 {
36595 #if wxUSE_UNICODE
36596 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36597 #else
36598 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36599 #endif
36600 }
36601 return resultobj;
36602 fail:
36603 return NULL;
36604 }
36605
36606
36607 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
36608 PyObject *resultobj = NULL;
36609 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36610 wxFrame *result;
36611 PyObject * obj0 = 0 ;
36612 char *kwnames[] = {
36613 (char *) "self", NULL
36614 };
36615
36616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
36617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36618 if (SWIG_arg_fail(1)) SWIG_fail;
36619 {
36620 PyThreadState* __tstate = wxPyBeginAllowThreads();
36621 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
36622
36623 wxPyEndAllowThreads(__tstate);
36624 if (PyErr_Occurred()) SWIG_fail;
36625 }
36626 {
36627 resultobj = wxPyMake_wxObject(result, (bool)0);
36628 }
36629 return resultobj;
36630 fail:
36631 return NULL;
36632 }
36633
36634
36635 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
36636 PyObject *resultobj = NULL;
36637 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36638 bool result;
36639 PyObject * obj0 = 0 ;
36640 char *kwnames[] = {
36641 (char *) "self", NULL
36642 };
36643
36644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
36645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36646 if (SWIG_arg_fail(1)) SWIG_fail;
36647 {
36648 PyThreadState* __tstate = wxPyBeginAllowThreads();
36649 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
36650
36651 wxPyEndAllowThreads(__tstate);
36652 if (PyErr_Occurred()) SWIG_fail;
36653 }
36654 {
36655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36656 }
36657 return resultobj;
36658 fail:
36659 return NULL;
36660 }
36661
36662
36663 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
36664 PyObject *resultobj = NULL;
36665 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36666 wxFrame *arg2 = (wxFrame *) 0 ;
36667 PyObject * obj0 = 0 ;
36668 PyObject * obj1 = 0 ;
36669 char *kwnames[] = {
36670 (char *) "self",(char *) "frame", NULL
36671 };
36672
36673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
36674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36675 if (SWIG_arg_fail(1)) SWIG_fail;
36676 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
36677 if (SWIG_arg_fail(2)) SWIG_fail;
36678 {
36679 PyThreadState* __tstate = wxPyBeginAllowThreads();
36680 (arg1)->Attach(arg2);
36681
36682 wxPyEndAllowThreads(__tstate);
36683 if (PyErr_Occurred()) SWIG_fail;
36684 }
36685 Py_INCREF(Py_None); resultobj = Py_None;
36686 return resultobj;
36687 fail:
36688 return NULL;
36689 }
36690
36691
36692 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
36693 PyObject *resultobj = NULL;
36694 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36695 PyObject * obj0 = 0 ;
36696 char *kwnames[] = {
36697 (char *) "self", NULL
36698 };
36699
36700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
36701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36702 if (SWIG_arg_fail(1)) SWIG_fail;
36703 {
36704 PyThreadState* __tstate = wxPyBeginAllowThreads();
36705 (arg1)->Detach();
36706
36707 wxPyEndAllowThreads(__tstate);
36708 if (PyErr_Occurred()) SWIG_fail;
36709 }
36710 Py_INCREF(Py_None); resultobj = Py_None;
36711 return resultobj;
36712 fail:
36713 return NULL;
36714 }
36715
36716
36717 static PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36718 PyObject *resultobj = NULL;
36719 bool arg1 ;
36720 PyObject * obj0 = 0 ;
36721 char *kwnames[] = {
36722 (char *) "enable", NULL
36723 };
36724
36725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) goto fail;
36726 {
36727 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
36728 if (SWIG_arg_fail(1)) SWIG_fail;
36729 }
36730 {
36731 PyThreadState* __tstate = wxPyBeginAllowThreads();
36732 wxMenuBar_SetAutoWindowMenu(arg1);
36733
36734 wxPyEndAllowThreads(__tstate);
36735 if (PyErr_Occurred()) SWIG_fail;
36736 }
36737 Py_INCREF(Py_None); resultobj = Py_None;
36738 return resultobj;
36739 fail:
36740 return NULL;
36741 }
36742
36743
36744 static PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36745 PyObject *resultobj = NULL;
36746 bool result;
36747 char *kwnames[] = {
36748 NULL
36749 };
36750
36751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuBar_GetAutoWindowMenu",kwnames)) goto fail;
36752 {
36753 PyThreadState* __tstate = wxPyBeginAllowThreads();
36754 result = (bool)wxMenuBar_GetAutoWindowMenu();
36755
36756 wxPyEndAllowThreads(__tstate);
36757 if (PyErr_Occurred()) SWIG_fail;
36758 }
36759 {
36760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36761 }
36762 return resultobj;
36763 fail:
36764 return NULL;
36765 }
36766
36767
36768 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
36769 PyObject *obj;
36770 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36771 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
36772 Py_INCREF(obj);
36773 return Py_BuildValue((char *)"");
36774 }
36775 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36776 PyObject *resultobj = NULL;
36777 wxMenu *arg1 = (wxMenu *) NULL ;
36778 int arg2 = (int) wxID_ANY ;
36779 wxString const &arg3_defvalue = wxPyEmptyString ;
36780 wxString *arg3 = (wxString *) &arg3_defvalue ;
36781 wxString const &arg4_defvalue = wxPyEmptyString ;
36782 wxString *arg4 = (wxString *) &arg4_defvalue ;
36783 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
36784 wxMenu *arg6 = (wxMenu *) NULL ;
36785 wxMenuItem *result;
36786 bool temp3 = false ;
36787 bool temp4 = false ;
36788 PyObject * obj0 = 0 ;
36789 PyObject * obj1 = 0 ;
36790 PyObject * obj2 = 0 ;
36791 PyObject * obj3 = 0 ;
36792 PyObject * obj4 = 0 ;
36793 PyObject * obj5 = 0 ;
36794 char *kwnames[] = {
36795 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
36796 };
36797
36798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
36799 if (obj0) {
36800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36801 if (SWIG_arg_fail(1)) SWIG_fail;
36802 }
36803 if (obj1) {
36804 {
36805 arg2 = static_cast<int >(SWIG_As_int(obj1));
36806 if (SWIG_arg_fail(2)) SWIG_fail;
36807 }
36808 }
36809 if (obj2) {
36810 {
36811 arg3 = wxString_in_helper(obj2);
36812 if (arg3 == NULL) SWIG_fail;
36813 temp3 = true;
36814 }
36815 }
36816 if (obj3) {
36817 {
36818 arg4 = wxString_in_helper(obj3);
36819 if (arg4 == NULL) SWIG_fail;
36820 temp4 = true;
36821 }
36822 }
36823 if (obj4) {
36824 {
36825 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
36826 if (SWIG_arg_fail(5)) SWIG_fail;
36827 }
36828 }
36829 if (obj5) {
36830 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36831 if (SWIG_arg_fail(6)) SWIG_fail;
36832 }
36833 {
36834 PyThreadState* __tstate = wxPyBeginAllowThreads();
36835 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
36836
36837 wxPyEndAllowThreads(__tstate);
36838 if (PyErr_Occurred()) SWIG_fail;
36839 }
36840 {
36841 resultobj = wxPyMake_wxObject(result, (bool)1);
36842 }
36843 {
36844 if (temp3)
36845 delete arg3;
36846 }
36847 {
36848 if (temp4)
36849 delete arg4;
36850 }
36851 return resultobj;
36852 fail:
36853 {
36854 if (temp3)
36855 delete arg3;
36856 }
36857 {
36858 if (temp4)
36859 delete arg4;
36860 }
36861 return NULL;
36862 }
36863
36864
36865 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36866 PyObject *resultobj = NULL;
36867 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36868 wxMenu *result;
36869 PyObject * obj0 = 0 ;
36870 char *kwnames[] = {
36871 (char *) "self", NULL
36872 };
36873
36874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36876 if (SWIG_arg_fail(1)) SWIG_fail;
36877 {
36878 PyThreadState* __tstate = wxPyBeginAllowThreads();
36879 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36880
36881 wxPyEndAllowThreads(__tstate);
36882 if (PyErr_Occurred()) SWIG_fail;
36883 }
36884 {
36885 resultobj = wxPyMake_wxObject(result, 0);
36886 }
36887 return resultobj;
36888 fail:
36889 return NULL;
36890 }
36891
36892
36893 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36894 PyObject *resultobj = NULL;
36895 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36896 wxMenu *arg2 = (wxMenu *) 0 ;
36897 PyObject * obj0 = 0 ;
36898 PyObject * obj1 = 0 ;
36899 char *kwnames[] = {
36900 (char *) "self",(char *) "menu", NULL
36901 };
36902
36903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36905 if (SWIG_arg_fail(1)) SWIG_fail;
36906 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36907 if (SWIG_arg_fail(2)) SWIG_fail;
36908 {
36909 PyThreadState* __tstate = wxPyBeginAllowThreads();
36910 (arg1)->SetMenu(arg2);
36911
36912 wxPyEndAllowThreads(__tstate);
36913 if (PyErr_Occurred()) SWIG_fail;
36914 }
36915 Py_INCREF(Py_None); resultobj = Py_None;
36916 return resultobj;
36917 fail:
36918 return NULL;
36919 }
36920
36921
36922 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36923 PyObject *resultobj = NULL;
36924 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36925 int arg2 ;
36926 PyObject * obj0 = 0 ;
36927 PyObject * obj1 = 0 ;
36928 char *kwnames[] = {
36929 (char *) "self",(char *) "id", NULL
36930 };
36931
36932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36934 if (SWIG_arg_fail(1)) SWIG_fail;
36935 {
36936 arg2 = static_cast<int >(SWIG_As_int(obj1));
36937 if (SWIG_arg_fail(2)) SWIG_fail;
36938 }
36939 {
36940 PyThreadState* __tstate = wxPyBeginAllowThreads();
36941 (arg1)->SetId(arg2);
36942
36943 wxPyEndAllowThreads(__tstate);
36944 if (PyErr_Occurred()) SWIG_fail;
36945 }
36946 Py_INCREF(Py_None); resultobj = Py_None;
36947 return resultobj;
36948 fail:
36949 return NULL;
36950 }
36951
36952
36953 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36954 PyObject *resultobj = NULL;
36955 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36956 int result;
36957 PyObject * obj0 = 0 ;
36958 char *kwnames[] = {
36959 (char *) "self", NULL
36960 };
36961
36962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36964 if (SWIG_arg_fail(1)) SWIG_fail;
36965 {
36966 PyThreadState* __tstate = wxPyBeginAllowThreads();
36967 result = (int)((wxMenuItem const *)arg1)->GetId();
36968
36969 wxPyEndAllowThreads(__tstate);
36970 if (PyErr_Occurred()) SWIG_fail;
36971 }
36972 {
36973 resultobj = SWIG_From_int(static_cast<int >(result));
36974 }
36975 return resultobj;
36976 fail:
36977 return NULL;
36978 }
36979
36980
36981 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36982 PyObject *resultobj = NULL;
36983 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36984 bool result;
36985 PyObject * obj0 = 0 ;
36986 char *kwnames[] = {
36987 (char *) "self", NULL
36988 };
36989
36990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36992 if (SWIG_arg_fail(1)) SWIG_fail;
36993 {
36994 PyThreadState* __tstate = wxPyBeginAllowThreads();
36995 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36996
36997 wxPyEndAllowThreads(__tstate);
36998 if (PyErr_Occurred()) SWIG_fail;
36999 }
37000 {
37001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37002 }
37003 return resultobj;
37004 fail:
37005 return NULL;
37006 }
37007
37008
37009 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
37010 PyObject *resultobj = NULL;
37011 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37012 wxString *arg2 = 0 ;
37013 bool temp2 = false ;
37014 PyObject * obj0 = 0 ;
37015 PyObject * obj1 = 0 ;
37016 char *kwnames[] = {
37017 (char *) "self",(char *) "str", NULL
37018 };
37019
37020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
37021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37022 if (SWIG_arg_fail(1)) SWIG_fail;
37023 {
37024 arg2 = wxString_in_helper(obj1);
37025 if (arg2 == NULL) SWIG_fail;
37026 temp2 = true;
37027 }
37028 {
37029 PyThreadState* __tstate = wxPyBeginAllowThreads();
37030 (arg1)->SetText((wxString const &)*arg2);
37031
37032 wxPyEndAllowThreads(__tstate);
37033 if (PyErr_Occurred()) SWIG_fail;
37034 }
37035 Py_INCREF(Py_None); resultobj = Py_None;
37036 {
37037 if (temp2)
37038 delete arg2;
37039 }
37040 return resultobj;
37041 fail:
37042 {
37043 if (temp2)
37044 delete arg2;
37045 }
37046 return NULL;
37047 }
37048
37049
37050 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37051 PyObject *resultobj = NULL;
37052 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37053 wxString result;
37054 PyObject * obj0 = 0 ;
37055 char *kwnames[] = {
37056 (char *) "self", NULL
37057 };
37058
37059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
37060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37061 if (SWIG_arg_fail(1)) SWIG_fail;
37062 {
37063 PyThreadState* __tstate = wxPyBeginAllowThreads();
37064 result = ((wxMenuItem const *)arg1)->GetLabel();
37065
37066 wxPyEndAllowThreads(__tstate);
37067 if (PyErr_Occurred()) SWIG_fail;
37068 }
37069 {
37070 #if wxUSE_UNICODE
37071 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37072 #else
37073 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37074 #endif
37075 }
37076 return resultobj;
37077 fail:
37078 return NULL;
37079 }
37080
37081
37082 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
37083 PyObject *resultobj = NULL;
37084 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37085 wxString *result;
37086 PyObject * obj0 = 0 ;
37087 char *kwnames[] = {
37088 (char *) "self", NULL
37089 };
37090
37091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
37092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37093 if (SWIG_arg_fail(1)) SWIG_fail;
37094 {
37095 PyThreadState* __tstate = wxPyBeginAllowThreads();
37096 {
37097 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
37098 result = (wxString *) &_result_ref;
37099 }
37100
37101 wxPyEndAllowThreads(__tstate);
37102 if (PyErr_Occurred()) SWIG_fail;
37103 }
37104 {
37105 #if wxUSE_UNICODE
37106 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37107 #else
37108 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37109 #endif
37110 }
37111 return resultobj;
37112 fail:
37113 return NULL;
37114 }
37115
37116
37117 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
37118 PyObject *resultobj = NULL;
37119 wxString *arg1 = 0 ;
37120 wxString result;
37121 bool temp1 = false ;
37122 PyObject * obj0 = 0 ;
37123 char *kwnames[] = {
37124 (char *) "text", NULL
37125 };
37126
37127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
37128 {
37129 arg1 = wxString_in_helper(obj0);
37130 if (arg1 == NULL) SWIG_fail;
37131 temp1 = true;
37132 }
37133 {
37134 PyThreadState* __tstate = wxPyBeginAllowThreads();
37135 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
37136
37137 wxPyEndAllowThreads(__tstate);
37138 if (PyErr_Occurred()) SWIG_fail;
37139 }
37140 {
37141 #if wxUSE_UNICODE
37142 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37143 #else
37144 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37145 #endif
37146 }
37147 {
37148 if (temp1)
37149 delete arg1;
37150 }
37151 return resultobj;
37152 fail:
37153 {
37154 if (temp1)
37155 delete arg1;
37156 }
37157 return NULL;
37158 }
37159
37160
37161 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
37162 PyObject *resultobj = NULL;
37163 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37164 wxItemKind result;
37165 PyObject * obj0 = 0 ;
37166 char *kwnames[] = {
37167 (char *) "self", NULL
37168 };
37169
37170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
37171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37172 if (SWIG_arg_fail(1)) SWIG_fail;
37173 {
37174 PyThreadState* __tstate = wxPyBeginAllowThreads();
37175 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
37176
37177 wxPyEndAllowThreads(__tstate);
37178 if (PyErr_Occurred()) SWIG_fail;
37179 }
37180 resultobj = SWIG_From_int((result));
37181 return resultobj;
37182 fail:
37183 return NULL;
37184 }
37185
37186
37187 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
37188 PyObject *resultobj = NULL;
37189 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37190 wxItemKind arg2 ;
37191 PyObject * obj0 = 0 ;
37192 PyObject * obj1 = 0 ;
37193 char *kwnames[] = {
37194 (char *) "self",(char *) "kind", NULL
37195 };
37196
37197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
37198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37199 if (SWIG_arg_fail(1)) SWIG_fail;
37200 {
37201 arg2 = static_cast<wxItemKind >(SWIG_As_int(obj1));
37202 if (SWIG_arg_fail(2)) SWIG_fail;
37203 }
37204 {
37205 PyThreadState* __tstate = wxPyBeginAllowThreads();
37206 (arg1)->SetKind(arg2);
37207
37208 wxPyEndAllowThreads(__tstate);
37209 if (PyErr_Occurred()) SWIG_fail;
37210 }
37211 Py_INCREF(Py_None); resultobj = Py_None;
37212 return resultobj;
37213 fail:
37214 return NULL;
37215 }
37216
37217
37218 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37219 PyObject *resultobj = NULL;
37220 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37221 bool arg2 ;
37222 PyObject * obj0 = 0 ;
37223 PyObject * obj1 = 0 ;
37224 char *kwnames[] = {
37225 (char *) "self",(char *) "checkable", NULL
37226 };
37227
37228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
37229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37230 if (SWIG_arg_fail(1)) SWIG_fail;
37231 {
37232 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37233 if (SWIG_arg_fail(2)) SWIG_fail;
37234 }
37235 {
37236 PyThreadState* __tstate = wxPyBeginAllowThreads();
37237 (arg1)->SetCheckable(arg2);
37238
37239 wxPyEndAllowThreads(__tstate);
37240 if (PyErr_Occurred()) SWIG_fail;
37241 }
37242 Py_INCREF(Py_None); resultobj = Py_None;
37243 return resultobj;
37244 fail:
37245 return NULL;
37246 }
37247
37248
37249 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37250 PyObject *resultobj = NULL;
37251 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37252 bool result;
37253 PyObject * obj0 = 0 ;
37254 char *kwnames[] = {
37255 (char *) "self", NULL
37256 };
37257
37258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
37259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37260 if (SWIG_arg_fail(1)) SWIG_fail;
37261 {
37262 PyThreadState* __tstate = wxPyBeginAllowThreads();
37263 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
37264
37265 wxPyEndAllowThreads(__tstate);
37266 if (PyErr_Occurred()) SWIG_fail;
37267 }
37268 {
37269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37270 }
37271 return resultobj;
37272 fail:
37273 return NULL;
37274 }
37275
37276
37277 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37278 PyObject *resultobj = NULL;
37279 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37280 bool result;
37281 PyObject * obj0 = 0 ;
37282 char *kwnames[] = {
37283 (char *) "self", NULL
37284 };
37285
37286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
37287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37288 if (SWIG_arg_fail(1)) SWIG_fail;
37289 {
37290 PyThreadState* __tstate = wxPyBeginAllowThreads();
37291 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
37292
37293 wxPyEndAllowThreads(__tstate);
37294 if (PyErr_Occurred()) SWIG_fail;
37295 }
37296 {
37297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37298 }
37299 return resultobj;
37300 fail:
37301 return NULL;
37302 }
37303
37304
37305 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37306 PyObject *resultobj = NULL;
37307 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37308 wxMenu *arg2 = (wxMenu *) 0 ;
37309 PyObject * obj0 = 0 ;
37310 PyObject * obj1 = 0 ;
37311 char *kwnames[] = {
37312 (char *) "self",(char *) "menu", NULL
37313 };
37314
37315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
37316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37317 if (SWIG_arg_fail(1)) SWIG_fail;
37318 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
37319 if (SWIG_arg_fail(2)) SWIG_fail;
37320 {
37321 PyThreadState* __tstate = wxPyBeginAllowThreads();
37322 (arg1)->SetSubMenu(arg2);
37323
37324 wxPyEndAllowThreads(__tstate);
37325 if (PyErr_Occurred()) SWIG_fail;
37326 }
37327 Py_INCREF(Py_None); resultobj = Py_None;
37328 return resultobj;
37329 fail:
37330 return NULL;
37331 }
37332
37333
37334 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37335 PyObject *resultobj = NULL;
37336 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37337 wxMenu *result;
37338 PyObject * obj0 = 0 ;
37339 char *kwnames[] = {
37340 (char *) "self", NULL
37341 };
37342
37343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
37344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37345 if (SWIG_arg_fail(1)) SWIG_fail;
37346 {
37347 PyThreadState* __tstate = wxPyBeginAllowThreads();
37348 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
37349
37350 wxPyEndAllowThreads(__tstate);
37351 if (PyErr_Occurred()) SWIG_fail;
37352 }
37353 {
37354 resultobj = wxPyMake_wxObject(result, 0);
37355 }
37356 return resultobj;
37357 fail:
37358 return NULL;
37359 }
37360
37361
37362 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
37363 PyObject *resultobj = NULL;
37364 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37365 bool arg2 = (bool) true ;
37366 PyObject * obj0 = 0 ;
37367 PyObject * obj1 = 0 ;
37368 char *kwnames[] = {
37369 (char *) "self",(char *) "enable", NULL
37370 };
37371
37372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
37373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37374 if (SWIG_arg_fail(1)) SWIG_fail;
37375 if (obj1) {
37376 {
37377 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37378 if (SWIG_arg_fail(2)) SWIG_fail;
37379 }
37380 }
37381 {
37382 PyThreadState* __tstate = wxPyBeginAllowThreads();
37383 (arg1)->Enable(arg2);
37384
37385 wxPyEndAllowThreads(__tstate);
37386 if (PyErr_Occurred()) SWIG_fail;
37387 }
37388 Py_INCREF(Py_None); resultobj = Py_None;
37389 return resultobj;
37390 fail:
37391 return NULL;
37392 }
37393
37394
37395 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
37396 PyObject *resultobj = NULL;
37397 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37398 bool result;
37399 PyObject * obj0 = 0 ;
37400 char *kwnames[] = {
37401 (char *) "self", NULL
37402 };
37403
37404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
37405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37406 if (SWIG_arg_fail(1)) SWIG_fail;
37407 {
37408 PyThreadState* __tstate = wxPyBeginAllowThreads();
37409 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
37410
37411 wxPyEndAllowThreads(__tstate);
37412 if (PyErr_Occurred()) SWIG_fail;
37413 }
37414 {
37415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37416 }
37417 return resultobj;
37418 fail:
37419 return NULL;
37420 }
37421
37422
37423 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
37424 PyObject *resultobj = NULL;
37425 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37426 bool arg2 = (bool) true ;
37427 PyObject * obj0 = 0 ;
37428 PyObject * obj1 = 0 ;
37429 char *kwnames[] = {
37430 (char *) "self",(char *) "check", NULL
37431 };
37432
37433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
37434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37435 if (SWIG_arg_fail(1)) SWIG_fail;
37436 if (obj1) {
37437 {
37438 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37439 if (SWIG_arg_fail(2)) SWIG_fail;
37440 }
37441 }
37442 {
37443 PyThreadState* __tstate = wxPyBeginAllowThreads();
37444 (arg1)->Check(arg2);
37445
37446 wxPyEndAllowThreads(__tstate);
37447 if (PyErr_Occurred()) SWIG_fail;
37448 }
37449 Py_INCREF(Py_None); resultobj = Py_None;
37450 return resultobj;
37451 fail:
37452 return NULL;
37453 }
37454
37455
37456 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
37457 PyObject *resultobj = NULL;
37458 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37459 bool result;
37460 PyObject * obj0 = 0 ;
37461 char *kwnames[] = {
37462 (char *) "self", NULL
37463 };
37464
37465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
37466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37467 if (SWIG_arg_fail(1)) SWIG_fail;
37468 {
37469 PyThreadState* __tstate = wxPyBeginAllowThreads();
37470 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
37471
37472 wxPyEndAllowThreads(__tstate);
37473 if (PyErr_Occurred()) SWIG_fail;
37474 }
37475 {
37476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37477 }
37478 return resultobj;
37479 fail:
37480 return NULL;
37481 }
37482
37483
37484 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
37485 PyObject *resultobj = NULL;
37486 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37487 PyObject * obj0 = 0 ;
37488 char *kwnames[] = {
37489 (char *) "self", NULL
37490 };
37491
37492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
37493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37494 if (SWIG_arg_fail(1)) SWIG_fail;
37495 {
37496 PyThreadState* __tstate = wxPyBeginAllowThreads();
37497 (arg1)->Toggle();
37498
37499 wxPyEndAllowThreads(__tstate);
37500 if (PyErr_Occurred()) SWIG_fail;
37501 }
37502 Py_INCREF(Py_None); resultobj = Py_None;
37503 return resultobj;
37504 fail:
37505 return NULL;
37506 }
37507
37508
37509 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37510 PyObject *resultobj = NULL;
37511 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37512 wxString *arg2 = 0 ;
37513 bool temp2 = false ;
37514 PyObject * obj0 = 0 ;
37515 PyObject * obj1 = 0 ;
37516 char *kwnames[] = {
37517 (char *) "self",(char *) "str", NULL
37518 };
37519
37520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
37521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37522 if (SWIG_arg_fail(1)) SWIG_fail;
37523 {
37524 arg2 = wxString_in_helper(obj1);
37525 if (arg2 == NULL) SWIG_fail;
37526 temp2 = true;
37527 }
37528 {
37529 PyThreadState* __tstate = wxPyBeginAllowThreads();
37530 (arg1)->SetHelp((wxString const &)*arg2);
37531
37532 wxPyEndAllowThreads(__tstate);
37533 if (PyErr_Occurred()) SWIG_fail;
37534 }
37535 Py_INCREF(Py_None); resultobj = Py_None;
37536 {
37537 if (temp2)
37538 delete arg2;
37539 }
37540 return resultobj;
37541 fail:
37542 {
37543 if (temp2)
37544 delete arg2;
37545 }
37546 return NULL;
37547 }
37548
37549
37550 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37551 PyObject *resultobj = NULL;
37552 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37553 wxString *result;
37554 PyObject * obj0 = 0 ;
37555 char *kwnames[] = {
37556 (char *) "self", NULL
37557 };
37558
37559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
37560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37561 if (SWIG_arg_fail(1)) SWIG_fail;
37562 {
37563 PyThreadState* __tstate = wxPyBeginAllowThreads();
37564 {
37565 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
37566 result = (wxString *) &_result_ref;
37567 }
37568
37569 wxPyEndAllowThreads(__tstate);
37570 if (PyErr_Occurred()) SWIG_fail;
37571 }
37572 {
37573 #if wxUSE_UNICODE
37574 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37575 #else
37576 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37577 #endif
37578 }
37579 return resultobj;
37580 fail:
37581 return NULL;
37582 }
37583
37584
37585 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37586 PyObject *resultobj = NULL;
37587 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37588 wxAcceleratorEntry *result;
37589 PyObject * obj0 = 0 ;
37590 char *kwnames[] = {
37591 (char *) "self", NULL
37592 };
37593
37594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
37595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37596 if (SWIG_arg_fail(1)) SWIG_fail;
37597 {
37598 PyThreadState* __tstate = wxPyBeginAllowThreads();
37599 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
37600
37601 wxPyEndAllowThreads(__tstate);
37602 if (PyErr_Occurred()) SWIG_fail;
37603 }
37604 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
37605 return resultobj;
37606 fail:
37607 return NULL;
37608 }
37609
37610
37611 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37612 PyObject *resultobj = NULL;
37613 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37614 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
37615 PyObject * obj0 = 0 ;
37616 PyObject * obj1 = 0 ;
37617 char *kwnames[] = {
37618 (char *) "self",(char *) "accel", NULL
37619 };
37620
37621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
37622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37623 if (SWIG_arg_fail(1)) SWIG_fail;
37624 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
37625 if (SWIG_arg_fail(2)) SWIG_fail;
37626 {
37627 PyThreadState* __tstate = wxPyBeginAllowThreads();
37628 (arg1)->SetAccel(arg2);
37629
37630 wxPyEndAllowThreads(__tstate);
37631 if (PyErr_Occurred()) SWIG_fail;
37632 }
37633 Py_INCREF(Py_None); resultobj = Py_None;
37634 return resultobj;
37635 fail:
37636 return NULL;
37637 }
37638
37639
37640 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37641 PyObject *resultobj = NULL;
37642 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37643 wxBitmap *arg2 = 0 ;
37644 PyObject * obj0 = 0 ;
37645 PyObject * obj1 = 0 ;
37646 char *kwnames[] = {
37647 (char *) "self",(char *) "bitmap", NULL
37648 };
37649
37650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37652 if (SWIG_arg_fail(1)) SWIG_fail;
37653 {
37654 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37655 if (SWIG_arg_fail(2)) SWIG_fail;
37656 if (arg2 == NULL) {
37657 SWIG_null_ref("wxBitmap");
37658 }
37659 if (SWIG_arg_fail(2)) SWIG_fail;
37660 }
37661 {
37662 PyThreadState* __tstate = wxPyBeginAllowThreads();
37663 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37664
37665 wxPyEndAllowThreads(__tstate);
37666 if (PyErr_Occurred()) SWIG_fail;
37667 }
37668 Py_INCREF(Py_None); resultobj = Py_None;
37669 return resultobj;
37670 fail:
37671 return NULL;
37672 }
37673
37674
37675 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37676 PyObject *resultobj = NULL;
37677 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37678 wxBitmap *result;
37679 PyObject * obj0 = 0 ;
37680 char *kwnames[] = {
37681 (char *) "self", NULL
37682 };
37683
37684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37686 if (SWIG_arg_fail(1)) SWIG_fail;
37687 {
37688 PyThreadState* __tstate = wxPyBeginAllowThreads();
37689 {
37690 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37691 result = (wxBitmap *) &_result_ref;
37692 }
37693
37694 wxPyEndAllowThreads(__tstate);
37695 if (PyErr_Occurred()) SWIG_fail;
37696 }
37697 {
37698 wxBitmap* resultptr = new wxBitmap(*result);
37699 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37700 }
37701 return resultobj;
37702 fail:
37703 return NULL;
37704 }
37705
37706
37707 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37708 PyObject *resultobj = NULL;
37709 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37710 wxFont *arg2 = 0 ;
37711 PyObject * obj0 = 0 ;
37712 PyObject * obj1 = 0 ;
37713 char *kwnames[] = {
37714 (char *) "self",(char *) "font", NULL
37715 };
37716
37717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
37718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37719 if (SWIG_arg_fail(1)) SWIG_fail;
37720 {
37721 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
37722 if (SWIG_arg_fail(2)) SWIG_fail;
37723 if (arg2 == NULL) {
37724 SWIG_null_ref("wxFont");
37725 }
37726 if (SWIG_arg_fail(2)) SWIG_fail;
37727 }
37728 {
37729 PyThreadState* __tstate = wxPyBeginAllowThreads();
37730 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
37731
37732 wxPyEndAllowThreads(__tstate);
37733 if (PyErr_Occurred()) SWIG_fail;
37734 }
37735 Py_INCREF(Py_None); resultobj = Py_None;
37736 return resultobj;
37737 fail:
37738 return NULL;
37739 }
37740
37741
37742 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37743 PyObject *resultobj = NULL;
37744 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37745 wxFont result;
37746 PyObject * obj0 = 0 ;
37747 char *kwnames[] = {
37748 (char *) "self", NULL
37749 };
37750
37751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
37752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37753 if (SWIG_arg_fail(1)) SWIG_fail;
37754 {
37755 PyThreadState* __tstate = wxPyBeginAllowThreads();
37756 result = wxMenuItem_GetFont(arg1);
37757
37758 wxPyEndAllowThreads(__tstate);
37759 if (PyErr_Occurred()) SWIG_fail;
37760 }
37761 {
37762 wxFont * resultptr;
37763 resultptr = new wxFont(static_cast<wxFont & >(result));
37764 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
37765 }
37766 return resultobj;
37767 fail:
37768 return NULL;
37769 }
37770
37771
37772 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37773 PyObject *resultobj = NULL;
37774 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37775 wxColour *arg2 = 0 ;
37776 wxColour temp2 ;
37777 PyObject * obj0 = 0 ;
37778 PyObject * obj1 = 0 ;
37779 char *kwnames[] = {
37780 (char *) "self",(char *) "colText", NULL
37781 };
37782
37783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
37784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37785 if (SWIG_arg_fail(1)) SWIG_fail;
37786 {
37787 arg2 = &temp2;
37788 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37789 }
37790 {
37791 PyThreadState* __tstate = wxPyBeginAllowThreads();
37792 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
37793
37794 wxPyEndAllowThreads(__tstate);
37795 if (PyErr_Occurred()) SWIG_fail;
37796 }
37797 Py_INCREF(Py_None); resultobj = Py_None;
37798 return resultobj;
37799 fail:
37800 return NULL;
37801 }
37802
37803
37804 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37805 PyObject *resultobj = NULL;
37806 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37807 wxColour result;
37808 PyObject * obj0 = 0 ;
37809 char *kwnames[] = {
37810 (char *) "self", NULL
37811 };
37812
37813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
37814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37815 if (SWIG_arg_fail(1)) SWIG_fail;
37816 {
37817 PyThreadState* __tstate = wxPyBeginAllowThreads();
37818 result = wxMenuItem_GetTextColour(arg1);
37819
37820 wxPyEndAllowThreads(__tstate);
37821 if (PyErr_Occurred()) SWIG_fail;
37822 }
37823 {
37824 wxColour * resultptr;
37825 resultptr = new wxColour(static_cast<wxColour & >(result));
37826 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37827 }
37828 return resultobj;
37829 fail:
37830 return NULL;
37831 }
37832
37833
37834 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37835 PyObject *resultobj = NULL;
37836 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37837 wxColour *arg2 = 0 ;
37838 wxColour temp2 ;
37839 PyObject * obj0 = 0 ;
37840 PyObject * obj1 = 0 ;
37841 char *kwnames[] = {
37842 (char *) "self",(char *) "colBack", NULL
37843 };
37844
37845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
37846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37847 if (SWIG_arg_fail(1)) SWIG_fail;
37848 {
37849 arg2 = &temp2;
37850 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37851 }
37852 {
37853 PyThreadState* __tstate = wxPyBeginAllowThreads();
37854 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
37855
37856 wxPyEndAllowThreads(__tstate);
37857 if (PyErr_Occurred()) SWIG_fail;
37858 }
37859 Py_INCREF(Py_None); resultobj = Py_None;
37860 return resultobj;
37861 fail:
37862 return NULL;
37863 }
37864
37865
37866 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37867 PyObject *resultobj = NULL;
37868 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37869 wxColour result;
37870 PyObject * obj0 = 0 ;
37871 char *kwnames[] = {
37872 (char *) "self", NULL
37873 };
37874
37875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
37876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37877 if (SWIG_arg_fail(1)) SWIG_fail;
37878 {
37879 PyThreadState* __tstate = wxPyBeginAllowThreads();
37880 result = wxMenuItem_GetBackgroundColour(arg1);
37881
37882 wxPyEndAllowThreads(__tstate);
37883 if (PyErr_Occurred()) SWIG_fail;
37884 }
37885 {
37886 wxColour * resultptr;
37887 resultptr = new wxColour(static_cast<wxColour & >(result));
37888 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37889 }
37890 return resultobj;
37891 fail:
37892 return NULL;
37893 }
37894
37895
37896 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
37897 PyObject *resultobj = NULL;
37898 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37899 wxBitmap *arg2 = 0 ;
37900 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37901 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37902 PyObject * obj0 = 0 ;
37903 PyObject * obj1 = 0 ;
37904 PyObject * obj2 = 0 ;
37905 char *kwnames[] = {
37906 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37907 };
37908
37909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37911 if (SWIG_arg_fail(1)) SWIG_fail;
37912 {
37913 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37914 if (SWIG_arg_fail(2)) SWIG_fail;
37915 if (arg2 == NULL) {
37916 SWIG_null_ref("wxBitmap");
37917 }
37918 if (SWIG_arg_fail(2)) SWIG_fail;
37919 }
37920 if (obj2) {
37921 {
37922 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37923 if (SWIG_arg_fail(3)) SWIG_fail;
37924 if (arg3 == NULL) {
37925 SWIG_null_ref("wxBitmap");
37926 }
37927 if (SWIG_arg_fail(3)) SWIG_fail;
37928 }
37929 }
37930 {
37931 PyThreadState* __tstate = wxPyBeginAllowThreads();
37932 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37933
37934 wxPyEndAllowThreads(__tstate);
37935 if (PyErr_Occurred()) SWIG_fail;
37936 }
37937 Py_INCREF(Py_None); resultobj = Py_None;
37938 return resultobj;
37939 fail:
37940 return NULL;
37941 }
37942
37943
37944 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37945 PyObject *resultobj = NULL;
37946 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37947 wxBitmap *arg2 = 0 ;
37948 PyObject * obj0 = 0 ;
37949 PyObject * obj1 = 0 ;
37950 char *kwnames[] = {
37951 (char *) "self",(char *) "bmpDisabled", NULL
37952 };
37953
37954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37956 if (SWIG_arg_fail(1)) SWIG_fail;
37957 {
37958 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37959 if (SWIG_arg_fail(2)) SWIG_fail;
37960 if (arg2 == NULL) {
37961 SWIG_null_ref("wxBitmap");
37962 }
37963 if (SWIG_arg_fail(2)) SWIG_fail;
37964 }
37965 {
37966 PyThreadState* __tstate = wxPyBeginAllowThreads();
37967 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
37968
37969 wxPyEndAllowThreads(__tstate);
37970 if (PyErr_Occurred()) SWIG_fail;
37971 }
37972 Py_INCREF(Py_None); resultobj = Py_None;
37973 return resultobj;
37974 fail:
37975 return NULL;
37976 }
37977
37978
37979 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37980 PyObject *resultobj = NULL;
37981 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37982 wxBitmap *result;
37983 PyObject * obj0 = 0 ;
37984 char *kwnames[] = {
37985 (char *) "self", NULL
37986 };
37987
37988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37990 if (SWIG_arg_fail(1)) SWIG_fail;
37991 {
37992 PyThreadState* __tstate = wxPyBeginAllowThreads();
37993 {
37994 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
37995 result = (wxBitmap *) &_result_ref;
37996 }
37997
37998 wxPyEndAllowThreads(__tstate);
37999 if (PyErr_Occurred()) SWIG_fail;
38000 }
38001 {
38002 wxBitmap* resultptr = new wxBitmap(*result);
38003 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
38004 }
38005 return resultobj;
38006 fail:
38007 return NULL;
38008 }
38009
38010
38011 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38012 PyObject *resultobj = NULL;
38013 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38014 int arg2 ;
38015 PyObject * obj0 = 0 ;
38016 PyObject * obj1 = 0 ;
38017 char *kwnames[] = {
38018 (char *) "self",(char *) "nWidth", NULL
38019 };
38020
38021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
38022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38023 if (SWIG_arg_fail(1)) SWIG_fail;
38024 {
38025 arg2 = static_cast<int >(SWIG_As_int(obj1));
38026 if (SWIG_arg_fail(2)) SWIG_fail;
38027 }
38028 {
38029 PyThreadState* __tstate = wxPyBeginAllowThreads();
38030 wxMenuItem_SetMarginWidth(arg1,arg2);
38031
38032 wxPyEndAllowThreads(__tstate);
38033 if (PyErr_Occurred()) SWIG_fail;
38034 }
38035 Py_INCREF(Py_None); resultobj = Py_None;
38036 return resultobj;
38037 fail:
38038 return NULL;
38039 }
38040
38041
38042 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38043 PyObject *resultobj = NULL;
38044 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38045 int result;
38046 PyObject * obj0 = 0 ;
38047 char *kwnames[] = {
38048 (char *) "self", NULL
38049 };
38050
38051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
38052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38053 if (SWIG_arg_fail(1)) SWIG_fail;
38054 {
38055 PyThreadState* __tstate = wxPyBeginAllowThreads();
38056 result = (int)wxMenuItem_GetMarginWidth(arg1);
38057
38058 wxPyEndAllowThreads(__tstate);
38059 if (PyErr_Occurred()) SWIG_fail;
38060 }
38061 {
38062 resultobj = SWIG_From_int(static_cast<int >(result));
38063 }
38064 return resultobj;
38065 fail:
38066 return NULL;
38067 }
38068
38069
38070 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38071 PyObject *resultobj = NULL;
38072 int result;
38073 char *kwnames[] = {
38074 NULL
38075 };
38076
38077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
38078 {
38079 PyThreadState* __tstate = wxPyBeginAllowThreads();
38080 result = (int)wxMenuItem_GetDefaultMarginWidth();
38081
38082 wxPyEndAllowThreads(__tstate);
38083 if (PyErr_Occurred()) SWIG_fail;
38084 }
38085 {
38086 resultobj = SWIG_From_int(static_cast<int >(result));
38087 }
38088 return resultobj;
38089 fail:
38090 return NULL;
38091 }
38092
38093
38094 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38095 PyObject *resultobj = NULL;
38096 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38097 bool result;
38098 PyObject * obj0 = 0 ;
38099 char *kwnames[] = {
38100 (char *) "self", NULL
38101 };
38102
38103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
38104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38105 if (SWIG_arg_fail(1)) SWIG_fail;
38106 {
38107 PyThreadState* __tstate = wxPyBeginAllowThreads();
38108 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
38109
38110 wxPyEndAllowThreads(__tstate);
38111 if (PyErr_Occurred()) SWIG_fail;
38112 }
38113 {
38114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38115 }
38116 return resultobj;
38117 fail:
38118 return NULL;
38119 }
38120
38121
38122 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38123 PyObject *resultobj = NULL;
38124 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38125 bool arg2 = (bool) true ;
38126 PyObject * obj0 = 0 ;
38127 PyObject * obj1 = 0 ;
38128 char *kwnames[] = {
38129 (char *) "self",(char *) "ownerDrawn", NULL
38130 };
38131
38132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
38133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38134 if (SWIG_arg_fail(1)) SWIG_fail;
38135 if (obj1) {
38136 {
38137 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
38138 if (SWIG_arg_fail(2)) SWIG_fail;
38139 }
38140 }
38141 {
38142 PyThreadState* __tstate = wxPyBeginAllowThreads();
38143 wxMenuItem_SetOwnerDrawn(arg1,arg2);
38144
38145 wxPyEndAllowThreads(__tstate);
38146 if (PyErr_Occurred()) SWIG_fail;
38147 }
38148 Py_INCREF(Py_None); resultobj = Py_None;
38149 return resultobj;
38150 fail:
38151 return NULL;
38152 }
38153
38154
38155 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38156 PyObject *resultobj = NULL;
38157 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38158 PyObject * obj0 = 0 ;
38159 char *kwnames[] = {
38160 (char *) "self", NULL
38161 };
38162
38163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
38164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38165 if (SWIG_arg_fail(1)) SWIG_fail;
38166 {
38167 PyThreadState* __tstate = wxPyBeginAllowThreads();
38168 wxMenuItem_ResetOwnerDrawn(arg1);
38169
38170 wxPyEndAllowThreads(__tstate);
38171 if (PyErr_Occurred()) SWIG_fail;
38172 }
38173 Py_INCREF(Py_None); resultobj = Py_None;
38174 return resultobj;
38175 fail:
38176 return NULL;
38177 }
38178
38179
38180 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
38181 PyObject *obj;
38182 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38183 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
38184 Py_INCREF(obj);
38185 return Py_BuildValue((char *)"");
38186 }
38187 static int _wrap_ControlNameStr_set(PyObject *) {
38188 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
38189 return 1;
38190 }
38191
38192
38193 static PyObject *_wrap_ControlNameStr_get(void) {
38194 PyObject *pyobj = NULL;
38195
38196 {
38197 #if wxUSE_UNICODE
38198 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
38199 #else
38200 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
38201 #endif
38202 }
38203 return pyobj;
38204 }
38205
38206
38207 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
38208 PyObject *resultobj = NULL;
38209 wxWindow *arg1 = (wxWindow *) 0 ;
38210 int arg2 = (int) -1 ;
38211 wxPoint const &arg3_defvalue = wxDefaultPosition ;
38212 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
38213 wxSize const &arg4_defvalue = wxDefaultSize ;
38214 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
38215 long arg5 = (long) 0 ;
38216 wxValidator const &arg6_defvalue = wxDefaultValidator ;
38217 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
38218 wxString const &arg7_defvalue = wxPyControlNameStr ;
38219 wxString *arg7 = (wxString *) &arg7_defvalue ;
38220 wxControl *result;
38221 wxPoint temp3 ;
38222 wxSize temp4 ;
38223 bool temp7 = false ;
38224 PyObject * obj0 = 0 ;
38225 PyObject * obj1 = 0 ;
38226 PyObject * obj2 = 0 ;
38227 PyObject * obj3 = 0 ;
38228 PyObject * obj4 = 0 ;
38229 PyObject * obj5 = 0 ;
38230 PyObject * obj6 = 0 ;
38231 char *kwnames[] = {
38232 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38233 };
38234
38235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38237 if (SWIG_arg_fail(1)) SWIG_fail;
38238 if (obj1) {
38239 {
38240 arg2 = static_cast<int >(SWIG_As_int(obj1));
38241 if (SWIG_arg_fail(2)) SWIG_fail;
38242 }
38243 }
38244 if (obj2) {
38245 {
38246 arg3 = &temp3;
38247 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
38248 }
38249 }
38250 if (obj3) {
38251 {
38252 arg4 = &temp4;
38253 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
38254 }
38255 }
38256 if (obj4) {
38257 {
38258 arg5 = static_cast<long >(SWIG_As_long(obj4));
38259 if (SWIG_arg_fail(5)) SWIG_fail;
38260 }
38261 }
38262 if (obj5) {
38263 {
38264 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38265 if (SWIG_arg_fail(6)) SWIG_fail;
38266 if (arg6 == NULL) {
38267 SWIG_null_ref("wxValidator");
38268 }
38269 if (SWIG_arg_fail(6)) SWIG_fail;
38270 }
38271 }
38272 if (obj6) {
38273 {
38274 arg7 = wxString_in_helper(obj6);
38275 if (arg7 == NULL) SWIG_fail;
38276 temp7 = true;
38277 }
38278 }
38279 {
38280 if (!wxPyCheckForApp()) SWIG_fail;
38281 PyThreadState* __tstate = wxPyBeginAllowThreads();
38282 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
38283
38284 wxPyEndAllowThreads(__tstate);
38285 if (PyErr_Occurred()) SWIG_fail;
38286 }
38287 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38288 {
38289 if (temp7)
38290 delete arg7;
38291 }
38292 return resultobj;
38293 fail:
38294 {
38295 if (temp7)
38296 delete arg7;
38297 }
38298 return NULL;
38299 }
38300
38301
38302 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
38303 PyObject *resultobj = NULL;
38304 wxControl *result;
38305 char *kwnames[] = {
38306 NULL
38307 };
38308
38309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
38310 {
38311 if (!wxPyCheckForApp()) SWIG_fail;
38312 PyThreadState* __tstate = wxPyBeginAllowThreads();
38313 result = (wxControl *)new wxControl();
38314
38315 wxPyEndAllowThreads(__tstate);
38316 if (PyErr_Occurred()) SWIG_fail;
38317 }
38318 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38319 return resultobj;
38320 fail:
38321 return NULL;
38322 }
38323
38324
38325 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
38326 PyObject *resultobj = NULL;
38327 wxControl *arg1 = (wxControl *) 0 ;
38328 wxWindow *arg2 = (wxWindow *) 0 ;
38329 int arg3 = (int) -1 ;
38330 wxPoint const &arg4_defvalue = wxDefaultPosition ;
38331 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
38332 wxSize const &arg5_defvalue = wxDefaultSize ;
38333 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
38334 long arg6 = (long) 0 ;
38335 wxValidator const &arg7_defvalue = wxDefaultValidator ;
38336 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
38337 wxString const &arg8_defvalue = wxPyControlNameStr ;
38338 wxString *arg8 = (wxString *) &arg8_defvalue ;
38339 bool result;
38340 wxPoint temp4 ;
38341 wxSize temp5 ;
38342 bool temp8 = false ;
38343 PyObject * obj0 = 0 ;
38344 PyObject * obj1 = 0 ;
38345 PyObject * obj2 = 0 ;
38346 PyObject * obj3 = 0 ;
38347 PyObject * obj4 = 0 ;
38348 PyObject * obj5 = 0 ;
38349 PyObject * obj6 = 0 ;
38350 PyObject * obj7 = 0 ;
38351 char *kwnames[] = {
38352 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38353 };
38354
38355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
38356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38357 if (SWIG_arg_fail(1)) SWIG_fail;
38358 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38359 if (SWIG_arg_fail(2)) SWIG_fail;
38360 if (obj2) {
38361 {
38362 arg3 = static_cast<int >(SWIG_As_int(obj2));
38363 if (SWIG_arg_fail(3)) SWIG_fail;
38364 }
38365 }
38366 if (obj3) {
38367 {
38368 arg4 = &temp4;
38369 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
38370 }
38371 }
38372 if (obj4) {
38373 {
38374 arg5 = &temp5;
38375 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
38376 }
38377 }
38378 if (obj5) {
38379 {
38380 arg6 = static_cast<long >(SWIG_As_long(obj5));
38381 if (SWIG_arg_fail(6)) SWIG_fail;
38382 }
38383 }
38384 if (obj6) {
38385 {
38386 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38387 if (SWIG_arg_fail(7)) SWIG_fail;
38388 if (arg7 == NULL) {
38389 SWIG_null_ref("wxValidator");
38390 }
38391 if (SWIG_arg_fail(7)) SWIG_fail;
38392 }
38393 }
38394 if (obj7) {
38395 {
38396 arg8 = wxString_in_helper(obj7);
38397 if (arg8 == NULL) SWIG_fail;
38398 temp8 = true;
38399 }
38400 }
38401 {
38402 PyThreadState* __tstate = wxPyBeginAllowThreads();
38403 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
38404
38405 wxPyEndAllowThreads(__tstate);
38406 if (PyErr_Occurred()) SWIG_fail;
38407 }
38408 {
38409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38410 }
38411 {
38412 if (temp8)
38413 delete arg8;
38414 }
38415 return resultobj;
38416 fail:
38417 {
38418 if (temp8)
38419 delete arg8;
38420 }
38421 return NULL;
38422 }
38423
38424
38425 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
38426 PyObject *resultobj = NULL;
38427 wxControl *arg1 = (wxControl *) 0 ;
38428 wxCommandEvent *arg2 = 0 ;
38429 PyObject * obj0 = 0 ;
38430 PyObject * obj1 = 0 ;
38431 char *kwnames[] = {
38432 (char *) "self",(char *) "event", NULL
38433 };
38434
38435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
38436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38437 if (SWIG_arg_fail(1)) SWIG_fail;
38438 {
38439 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
38440 if (SWIG_arg_fail(2)) SWIG_fail;
38441 if (arg2 == NULL) {
38442 SWIG_null_ref("wxCommandEvent");
38443 }
38444 if (SWIG_arg_fail(2)) SWIG_fail;
38445 }
38446 {
38447 PyThreadState* __tstate = wxPyBeginAllowThreads();
38448 (arg1)->Command(*arg2);
38449
38450 wxPyEndAllowThreads(__tstate);
38451 if (PyErr_Occurred()) SWIG_fail;
38452 }
38453 Py_INCREF(Py_None); resultobj = Py_None;
38454 return resultobj;
38455 fail:
38456 return NULL;
38457 }
38458
38459
38460 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38461 PyObject *resultobj = NULL;
38462 wxControl *arg1 = (wxControl *) 0 ;
38463 wxString result;
38464 PyObject * obj0 = 0 ;
38465 char *kwnames[] = {
38466 (char *) "self", NULL
38467 };
38468
38469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
38470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38471 if (SWIG_arg_fail(1)) SWIG_fail;
38472 {
38473 PyThreadState* __tstate = wxPyBeginAllowThreads();
38474 result = (arg1)->GetLabel();
38475
38476 wxPyEndAllowThreads(__tstate);
38477 if (PyErr_Occurred()) SWIG_fail;
38478 }
38479 {
38480 #if wxUSE_UNICODE
38481 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38482 #else
38483 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38484 #endif
38485 }
38486 return resultobj;
38487 fail:
38488 return NULL;
38489 }
38490
38491
38492 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38493 PyObject *resultobj = NULL;
38494 wxControl *arg1 = (wxControl *) 0 ;
38495 wxString *arg2 = 0 ;
38496 bool temp2 = false ;
38497 PyObject * obj0 = 0 ;
38498 PyObject * obj1 = 0 ;
38499 char *kwnames[] = {
38500 (char *) "self",(char *) "label", NULL
38501 };
38502
38503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
38504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38505 if (SWIG_arg_fail(1)) SWIG_fail;
38506 {
38507 arg2 = wxString_in_helper(obj1);
38508 if (arg2 == NULL) SWIG_fail;
38509 temp2 = true;
38510 }
38511 {
38512 PyThreadState* __tstate = wxPyBeginAllowThreads();
38513 (arg1)->SetLabel((wxString const &)*arg2);
38514
38515 wxPyEndAllowThreads(__tstate);
38516 if (PyErr_Occurred()) SWIG_fail;
38517 }
38518 Py_INCREF(Py_None); resultobj = Py_None;
38519 {
38520 if (temp2)
38521 delete arg2;
38522 }
38523 return resultobj;
38524 fail:
38525 {
38526 if (temp2)
38527 delete arg2;
38528 }
38529 return NULL;
38530 }
38531
38532
38533 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
38534 PyObject *resultobj = NULL;
38535 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38536 wxVisualAttributes result;
38537 PyObject * obj0 = 0 ;
38538 char *kwnames[] = {
38539 (char *) "variant", NULL
38540 };
38541
38542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
38543 if (obj0) {
38544 {
38545 arg1 = static_cast<wxWindowVariant >(SWIG_As_int(obj0));
38546 if (SWIG_arg_fail(1)) SWIG_fail;
38547 }
38548 }
38549 {
38550 if (!wxPyCheckForApp()) SWIG_fail;
38551 PyThreadState* __tstate = wxPyBeginAllowThreads();
38552 result = wxControl::GetClassDefaultAttributes(arg1);
38553
38554 wxPyEndAllowThreads(__tstate);
38555 if (PyErr_Occurred()) SWIG_fail;
38556 }
38557 {
38558 wxVisualAttributes * resultptr;
38559 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
38560 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
38561 }
38562 return resultobj;
38563 fail:
38564 return NULL;
38565 }
38566
38567
38568 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
38569 PyObject *obj;
38570 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38571 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
38572 Py_INCREF(obj);
38573 return Py_BuildValue((char *)"");
38574 }
38575 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
38576 PyObject *resultobj = NULL;
38577 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38578 wxString *arg2 = 0 ;
38579 PyObject *arg3 = (PyObject *) NULL ;
38580 int result;
38581 bool temp2 = false ;
38582 PyObject * obj0 = 0 ;
38583 PyObject * obj1 = 0 ;
38584 PyObject * obj2 = 0 ;
38585 char *kwnames[] = {
38586 (char *) "self",(char *) "item",(char *) "clientData", NULL
38587 };
38588
38589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
38590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38591 if (SWIG_arg_fail(1)) SWIG_fail;
38592 {
38593 arg2 = wxString_in_helper(obj1);
38594 if (arg2 == NULL) SWIG_fail;
38595 temp2 = true;
38596 }
38597 if (obj2) {
38598 arg3 = obj2;
38599 }
38600 {
38601 PyThreadState* __tstate = wxPyBeginAllowThreads();
38602 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
38603
38604 wxPyEndAllowThreads(__tstate);
38605 if (PyErr_Occurred()) SWIG_fail;
38606 }
38607 {
38608 resultobj = SWIG_From_int(static_cast<int >(result));
38609 }
38610 {
38611 if (temp2)
38612 delete arg2;
38613 }
38614 return resultobj;
38615 fail:
38616 {
38617 if (temp2)
38618 delete arg2;
38619 }
38620 return NULL;
38621 }
38622
38623
38624 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
38625 PyObject *resultobj = NULL;
38626 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38627 wxArrayString *arg2 = 0 ;
38628 bool temp2 = false ;
38629 PyObject * obj0 = 0 ;
38630 PyObject * obj1 = 0 ;
38631 char *kwnames[] = {
38632 (char *) "self",(char *) "strings", NULL
38633 };
38634
38635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
38636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38637 if (SWIG_arg_fail(1)) SWIG_fail;
38638 {
38639 if (! PySequence_Check(obj1)) {
38640 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38641 SWIG_fail;
38642 }
38643 arg2 = new wxArrayString;
38644 temp2 = true;
38645 int i, len=PySequence_Length(obj1);
38646 for (i=0; i<len; i++) {
38647 PyObject* item = PySequence_GetItem(obj1, i);
38648 wxString* s = wxString_in_helper(item);
38649 if (PyErr_Occurred()) SWIG_fail;
38650 arg2->Add(*s);
38651 delete s;
38652 Py_DECREF(item);
38653 }
38654 }
38655 {
38656 PyThreadState* __tstate = wxPyBeginAllowThreads();
38657 (arg1)->Append((wxArrayString const &)*arg2);
38658
38659 wxPyEndAllowThreads(__tstate);
38660 if (PyErr_Occurred()) SWIG_fail;
38661 }
38662 Py_INCREF(Py_None); resultobj = Py_None;
38663 {
38664 if (temp2) delete arg2;
38665 }
38666 return resultobj;
38667 fail:
38668 {
38669 if (temp2) delete arg2;
38670 }
38671 return NULL;
38672 }
38673
38674
38675 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38676 PyObject *resultobj = NULL;
38677 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38678 wxString *arg2 = 0 ;
38679 int arg3 ;
38680 PyObject *arg4 = (PyObject *) NULL ;
38681 int result;
38682 bool temp2 = false ;
38683 PyObject * obj0 = 0 ;
38684 PyObject * obj1 = 0 ;
38685 PyObject * obj2 = 0 ;
38686 PyObject * obj3 = 0 ;
38687 char *kwnames[] = {
38688 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
38689 };
38690
38691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
38692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38693 if (SWIG_arg_fail(1)) SWIG_fail;
38694 {
38695 arg2 = wxString_in_helper(obj1);
38696 if (arg2 == NULL) SWIG_fail;
38697 temp2 = true;
38698 }
38699 {
38700 arg3 = static_cast<int >(SWIG_As_int(obj2));
38701 if (SWIG_arg_fail(3)) SWIG_fail;
38702 }
38703 if (obj3) {
38704 arg4 = obj3;
38705 }
38706 {
38707 PyThreadState* __tstate = wxPyBeginAllowThreads();
38708 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
38709
38710 wxPyEndAllowThreads(__tstate);
38711 if (PyErr_Occurred()) SWIG_fail;
38712 }
38713 {
38714 resultobj = SWIG_From_int(static_cast<int >(result));
38715 }
38716 {
38717 if (temp2)
38718 delete arg2;
38719 }
38720 return resultobj;
38721 fail:
38722 {
38723 if (temp2)
38724 delete arg2;
38725 }
38726 return NULL;
38727 }
38728
38729
38730 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
38731 PyObject *resultobj = NULL;
38732 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38733 PyObject * obj0 = 0 ;
38734 char *kwnames[] = {
38735 (char *) "self", NULL
38736 };
38737
38738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
38739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38740 if (SWIG_arg_fail(1)) SWIG_fail;
38741 {
38742 PyThreadState* __tstate = wxPyBeginAllowThreads();
38743 (arg1)->Clear();
38744
38745 wxPyEndAllowThreads(__tstate);
38746 if (PyErr_Occurred()) SWIG_fail;
38747 }
38748 Py_INCREF(Py_None); resultobj = Py_None;
38749 return resultobj;
38750 fail:
38751 return NULL;
38752 }
38753
38754
38755 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
38756 PyObject *resultobj = NULL;
38757 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38758 int arg2 ;
38759 PyObject * obj0 = 0 ;
38760 PyObject * obj1 = 0 ;
38761 char *kwnames[] = {
38762 (char *) "self",(char *) "n", NULL
38763 };
38764
38765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
38766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38767 if (SWIG_arg_fail(1)) SWIG_fail;
38768 {
38769 arg2 = static_cast<int >(SWIG_As_int(obj1));
38770 if (SWIG_arg_fail(2)) SWIG_fail;
38771 }
38772 {
38773 PyThreadState* __tstate = wxPyBeginAllowThreads();
38774 (arg1)->Delete(arg2);
38775
38776 wxPyEndAllowThreads(__tstate);
38777 if (PyErr_Occurred()) SWIG_fail;
38778 }
38779 Py_INCREF(Py_None); resultobj = Py_None;
38780 return resultobj;
38781 fail:
38782 return NULL;
38783 }
38784
38785
38786 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38787 PyObject *resultobj = NULL;
38788 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38789 int arg2 ;
38790 PyObject *result;
38791 PyObject * obj0 = 0 ;
38792 PyObject * obj1 = 0 ;
38793 char *kwnames[] = {
38794 (char *) "self",(char *) "n", NULL
38795 };
38796
38797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
38798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38799 if (SWIG_arg_fail(1)) SWIG_fail;
38800 {
38801 arg2 = static_cast<int >(SWIG_As_int(obj1));
38802 if (SWIG_arg_fail(2)) SWIG_fail;
38803 }
38804 {
38805 PyThreadState* __tstate = wxPyBeginAllowThreads();
38806 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
38807
38808 wxPyEndAllowThreads(__tstate);
38809 if (PyErr_Occurred()) SWIG_fail;
38810 }
38811 resultobj = result;
38812 return resultobj;
38813 fail:
38814 return NULL;
38815 }
38816
38817
38818 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38819 PyObject *resultobj = NULL;
38820 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38821 int arg2 ;
38822 PyObject *arg3 = (PyObject *) 0 ;
38823 PyObject * obj0 = 0 ;
38824 PyObject * obj1 = 0 ;
38825 PyObject * obj2 = 0 ;
38826 char *kwnames[] = {
38827 (char *) "self",(char *) "n",(char *) "clientData", NULL
38828 };
38829
38830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38832 if (SWIG_arg_fail(1)) SWIG_fail;
38833 {
38834 arg2 = static_cast<int >(SWIG_As_int(obj1));
38835 if (SWIG_arg_fail(2)) SWIG_fail;
38836 }
38837 arg3 = obj2;
38838 {
38839 PyThreadState* __tstate = wxPyBeginAllowThreads();
38840 wxItemContainer_SetClientData(arg1,arg2,arg3);
38841
38842 wxPyEndAllowThreads(__tstate);
38843 if (PyErr_Occurred()) SWIG_fail;
38844 }
38845 Py_INCREF(Py_None); resultobj = Py_None;
38846 return resultobj;
38847 fail:
38848 return NULL;
38849 }
38850
38851
38852 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38853 PyObject *resultobj = NULL;
38854 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38855 int result;
38856 PyObject * obj0 = 0 ;
38857 char *kwnames[] = {
38858 (char *) "self", NULL
38859 };
38860
38861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38863 if (SWIG_arg_fail(1)) SWIG_fail;
38864 {
38865 PyThreadState* __tstate = wxPyBeginAllowThreads();
38866 result = (int)((wxItemContainer const *)arg1)->GetCount();
38867
38868 wxPyEndAllowThreads(__tstate);
38869 if (PyErr_Occurred()) SWIG_fail;
38870 }
38871 {
38872 resultobj = SWIG_From_int(static_cast<int >(result));
38873 }
38874 return resultobj;
38875 fail:
38876 return NULL;
38877 }
38878
38879
38880 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38881 PyObject *resultobj = NULL;
38882 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38883 bool result;
38884 PyObject * obj0 = 0 ;
38885 char *kwnames[] = {
38886 (char *) "self", NULL
38887 };
38888
38889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38891 if (SWIG_arg_fail(1)) SWIG_fail;
38892 {
38893 PyThreadState* __tstate = wxPyBeginAllowThreads();
38894 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38895
38896 wxPyEndAllowThreads(__tstate);
38897 if (PyErr_Occurred()) SWIG_fail;
38898 }
38899 {
38900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38901 }
38902 return resultobj;
38903 fail:
38904 return NULL;
38905 }
38906
38907
38908 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38909 PyObject *resultobj = NULL;
38910 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38911 int arg2 ;
38912 wxString result;
38913 PyObject * obj0 = 0 ;
38914 PyObject * obj1 = 0 ;
38915 char *kwnames[] = {
38916 (char *) "self",(char *) "n", NULL
38917 };
38918
38919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38921 if (SWIG_arg_fail(1)) SWIG_fail;
38922 {
38923 arg2 = static_cast<int >(SWIG_As_int(obj1));
38924 if (SWIG_arg_fail(2)) SWIG_fail;
38925 }
38926 {
38927 PyThreadState* __tstate = wxPyBeginAllowThreads();
38928 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38929
38930 wxPyEndAllowThreads(__tstate);
38931 if (PyErr_Occurred()) SWIG_fail;
38932 }
38933 {
38934 #if wxUSE_UNICODE
38935 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38936 #else
38937 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38938 #endif
38939 }
38940 return resultobj;
38941 fail:
38942 return NULL;
38943 }
38944
38945
38946 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38947 PyObject *resultobj = NULL;
38948 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38949 wxArrayString result;
38950 PyObject * obj0 = 0 ;
38951 char *kwnames[] = {
38952 (char *) "self", NULL
38953 };
38954
38955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38957 if (SWIG_arg_fail(1)) SWIG_fail;
38958 {
38959 PyThreadState* __tstate = wxPyBeginAllowThreads();
38960 result = ((wxItemContainer const *)arg1)->GetStrings();
38961
38962 wxPyEndAllowThreads(__tstate);
38963 if (PyErr_Occurred()) SWIG_fail;
38964 }
38965 {
38966 resultobj = wxArrayString2PyList_helper(result);
38967 }
38968 return resultobj;
38969 fail:
38970 return NULL;
38971 }
38972
38973
38974 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38975 PyObject *resultobj = NULL;
38976 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38977 int arg2 ;
38978 wxString *arg3 = 0 ;
38979 bool temp3 = false ;
38980 PyObject * obj0 = 0 ;
38981 PyObject * obj1 = 0 ;
38982 PyObject * obj2 = 0 ;
38983 char *kwnames[] = {
38984 (char *) "self",(char *) "n",(char *) "s", NULL
38985 };
38986
38987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38989 if (SWIG_arg_fail(1)) SWIG_fail;
38990 {
38991 arg2 = static_cast<int >(SWIG_As_int(obj1));
38992 if (SWIG_arg_fail(2)) SWIG_fail;
38993 }
38994 {
38995 arg3 = wxString_in_helper(obj2);
38996 if (arg3 == NULL) SWIG_fail;
38997 temp3 = true;
38998 }
38999 {
39000 PyThreadState* __tstate = wxPyBeginAllowThreads();
39001 (arg1)->SetString(arg2,(wxString const &)*arg3);
39002
39003 wxPyEndAllowThreads(__tstate);
39004 if (PyErr_Occurred()) SWIG_fail;
39005 }
39006 Py_INCREF(Py_None); resultobj = Py_None;
39007 {
39008 if (temp3)
39009 delete arg3;
39010 }
39011 return resultobj;
39012 fail:
39013 {
39014 if (temp3)
39015 delete arg3;
39016 }
39017 return NULL;
39018 }
39019
39020
39021 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
39022 PyObject *resultobj = NULL;
39023 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39024 wxString *arg2 = 0 ;
39025 int result;
39026 bool temp2 = false ;
39027 PyObject * obj0 = 0 ;
39028 PyObject * obj1 = 0 ;
39029 char *kwnames[] = {
39030 (char *) "self",(char *) "s", NULL
39031 };
39032
39033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
39034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39035 if (SWIG_arg_fail(1)) SWIG_fail;
39036 {
39037 arg2 = wxString_in_helper(obj1);
39038 if (arg2 == NULL) SWIG_fail;
39039 temp2 = true;
39040 }
39041 {
39042 PyThreadState* __tstate = wxPyBeginAllowThreads();
39043 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
39044
39045 wxPyEndAllowThreads(__tstate);
39046 if (PyErr_Occurred()) SWIG_fail;
39047 }
39048 {
39049 resultobj = SWIG_From_int(static_cast<int >(result));
39050 }
39051 {
39052 if (temp2)
39053 delete arg2;
39054 }
39055 return resultobj;
39056 fail:
39057 {
39058 if (temp2)
39059 delete arg2;
39060 }
39061 return NULL;
39062 }
39063
39064
39065 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39066 PyObject *resultobj = NULL;
39067 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39068 int arg2 ;
39069 PyObject * obj0 = 0 ;
39070 PyObject * obj1 = 0 ;
39071 char *kwnames[] = {
39072 (char *) "self",(char *) "n", NULL
39073 };
39074
39075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
39076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39077 if (SWIG_arg_fail(1)) SWIG_fail;
39078 {
39079 arg2 = static_cast<int >(SWIG_As_int(obj1));
39080 if (SWIG_arg_fail(2)) SWIG_fail;
39081 }
39082 {
39083 PyThreadState* __tstate = wxPyBeginAllowThreads();
39084 (arg1)->SetSelection(arg2);
39085
39086 wxPyEndAllowThreads(__tstate);
39087 if (PyErr_Occurred()) SWIG_fail;
39088 }
39089 Py_INCREF(Py_None); resultobj = Py_None;
39090 return resultobj;
39091 fail:
39092 return NULL;
39093 }
39094
39095
39096 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39097 PyObject *resultobj = NULL;
39098 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39099 int result;
39100 PyObject * obj0 = 0 ;
39101 char *kwnames[] = {
39102 (char *) "self", NULL
39103 };
39104
39105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
39106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39107 if (SWIG_arg_fail(1)) SWIG_fail;
39108 {
39109 PyThreadState* __tstate = wxPyBeginAllowThreads();
39110 result = (int)((wxItemContainer const *)arg1)->GetSelection();
39111
39112 wxPyEndAllowThreads(__tstate);
39113 if (PyErr_Occurred()) SWIG_fail;
39114 }
39115 {
39116 resultobj = SWIG_From_int(static_cast<int >(result));
39117 }
39118 return resultobj;
39119 fail:
39120 return NULL;
39121 }
39122
39123
39124 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39125 PyObject *resultobj = NULL;
39126 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39127 wxString *arg2 = 0 ;
39128 bool result;
39129 bool temp2 = false ;
39130 PyObject * obj0 = 0 ;
39131 PyObject * obj1 = 0 ;
39132 char *kwnames[] = {
39133 (char *) "self",(char *) "s", NULL
39134 };
39135
39136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
39137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39138 if (SWIG_arg_fail(1)) SWIG_fail;
39139 {
39140 arg2 = wxString_in_helper(obj1);
39141 if (arg2 == NULL) SWIG_fail;
39142 temp2 = true;
39143 }
39144 {
39145 PyThreadState* __tstate = wxPyBeginAllowThreads();
39146 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
39147
39148 wxPyEndAllowThreads(__tstate);
39149 if (PyErr_Occurred()) SWIG_fail;
39150 }
39151 {
39152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39153 }
39154 {
39155 if (temp2)
39156 delete arg2;
39157 }
39158 return resultobj;
39159 fail:
39160 {
39161 if (temp2)
39162 delete arg2;
39163 }
39164 return NULL;
39165 }
39166
39167
39168 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39169 PyObject *resultobj = NULL;
39170 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39171 wxString result;
39172 PyObject * obj0 = 0 ;
39173 char *kwnames[] = {
39174 (char *) "self", NULL
39175 };
39176
39177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
39178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39179 if (SWIG_arg_fail(1)) SWIG_fail;
39180 {
39181 PyThreadState* __tstate = wxPyBeginAllowThreads();
39182 result = ((wxItemContainer const *)arg1)->GetStringSelection();
39183
39184 wxPyEndAllowThreads(__tstate);
39185 if (PyErr_Occurred()) SWIG_fail;
39186 }
39187 {
39188 #if wxUSE_UNICODE
39189 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39190 #else
39191 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39192 #endif
39193 }
39194 return resultobj;
39195 fail:
39196 return NULL;
39197 }
39198
39199
39200 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
39201 PyObject *resultobj = NULL;
39202 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39203 int arg2 ;
39204 PyObject * obj0 = 0 ;
39205 PyObject * obj1 = 0 ;
39206 char *kwnames[] = {
39207 (char *) "self",(char *) "n", NULL
39208 };
39209
39210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
39211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39212 if (SWIG_arg_fail(1)) SWIG_fail;
39213 {
39214 arg2 = static_cast<int >(SWIG_As_int(obj1));
39215 if (SWIG_arg_fail(2)) SWIG_fail;
39216 }
39217 {
39218 PyThreadState* __tstate = wxPyBeginAllowThreads();
39219 (arg1)->Select(arg2);
39220
39221 wxPyEndAllowThreads(__tstate);
39222 if (PyErr_Occurred()) SWIG_fail;
39223 }
39224 Py_INCREF(Py_None); resultobj = Py_None;
39225 return resultobj;
39226 fail:
39227 return NULL;
39228 }
39229
39230
39231 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
39232 PyObject *obj;
39233 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39234 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
39235 Py_INCREF(obj);
39236 return Py_BuildValue((char *)"");
39237 }
39238 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
39239 PyObject *obj;
39240 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39241 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
39242 Py_INCREF(obj);
39243 return Py_BuildValue((char *)"");
39244 }
39245 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
39246 PyObject *resultobj = NULL;
39247 wxSizerItem *result;
39248 char *kwnames[] = {
39249 NULL
39250 };
39251
39252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
39253 {
39254 PyThreadState* __tstate = wxPyBeginAllowThreads();
39255 result = (wxSizerItem *)new wxSizerItem();
39256
39257 wxPyEndAllowThreads(__tstate);
39258 if (PyErr_Occurred()) SWIG_fail;
39259 }
39260 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39261 return resultobj;
39262 fail:
39263 return NULL;
39264 }
39265
39266
39267 static PyObject *_wrap_delete_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
39268 PyObject *resultobj = NULL;
39269 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39270 PyObject * obj0 = 0 ;
39271 char *kwnames[] = {
39272 (char *) "self", NULL
39273 };
39274
39275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SizerItem",kwnames,&obj0)) goto fail;
39276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39277 if (SWIG_arg_fail(1)) SWIG_fail;
39278 {
39279 PyThreadState* __tstate = wxPyBeginAllowThreads();
39280 delete arg1;
39281
39282 wxPyEndAllowThreads(__tstate);
39283 if (PyErr_Occurred()) SWIG_fail;
39284 }
39285 Py_INCREF(Py_None); resultobj = Py_None;
39286 return resultobj;
39287 fail:
39288 return NULL;
39289 }
39290
39291
39292 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39293 PyObject *resultobj = NULL;
39294 wxWindow *arg1 = (wxWindow *) 0 ;
39295 int arg2 ;
39296 int arg3 ;
39297 int arg4 ;
39298 PyObject *arg5 = (PyObject *) NULL ;
39299 wxSizerItem *result;
39300 PyObject * obj0 = 0 ;
39301 PyObject * obj1 = 0 ;
39302 PyObject * obj2 = 0 ;
39303 PyObject * obj3 = 0 ;
39304 PyObject * obj4 = 0 ;
39305 char *kwnames[] = {
39306 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39307 };
39308
39309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39311 if (SWIG_arg_fail(1)) SWIG_fail;
39312 {
39313 arg2 = static_cast<int >(SWIG_As_int(obj1));
39314 if (SWIG_arg_fail(2)) SWIG_fail;
39315 }
39316 {
39317 arg3 = static_cast<int >(SWIG_As_int(obj2));
39318 if (SWIG_arg_fail(3)) SWIG_fail;
39319 }
39320 {
39321 arg4 = static_cast<int >(SWIG_As_int(obj3));
39322 if (SWIG_arg_fail(4)) SWIG_fail;
39323 }
39324 if (obj4) {
39325 arg5 = obj4;
39326 }
39327 {
39328 PyThreadState* __tstate = wxPyBeginAllowThreads();
39329 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39330
39331 wxPyEndAllowThreads(__tstate);
39332 if (PyErr_Occurred()) SWIG_fail;
39333 }
39334 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39335 return resultobj;
39336 fail:
39337 return NULL;
39338 }
39339
39340
39341 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39342 PyObject *resultobj = NULL;
39343 int arg1 ;
39344 int arg2 ;
39345 int arg3 ;
39346 int arg4 ;
39347 int arg5 ;
39348 PyObject *arg6 = (PyObject *) NULL ;
39349 wxSizerItem *result;
39350 PyObject * obj0 = 0 ;
39351 PyObject * obj1 = 0 ;
39352 PyObject * obj2 = 0 ;
39353 PyObject * obj3 = 0 ;
39354 PyObject * obj4 = 0 ;
39355 PyObject * obj5 = 0 ;
39356 char *kwnames[] = {
39357 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39358 };
39359
39360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39361 {
39362 arg1 = static_cast<int >(SWIG_As_int(obj0));
39363 if (SWIG_arg_fail(1)) SWIG_fail;
39364 }
39365 {
39366 arg2 = static_cast<int >(SWIG_As_int(obj1));
39367 if (SWIG_arg_fail(2)) SWIG_fail;
39368 }
39369 {
39370 arg3 = static_cast<int >(SWIG_As_int(obj2));
39371 if (SWIG_arg_fail(3)) SWIG_fail;
39372 }
39373 {
39374 arg4 = static_cast<int >(SWIG_As_int(obj3));
39375 if (SWIG_arg_fail(4)) SWIG_fail;
39376 }
39377 {
39378 arg5 = static_cast<int >(SWIG_As_int(obj4));
39379 if (SWIG_arg_fail(5)) SWIG_fail;
39380 }
39381 if (obj5) {
39382 arg6 = obj5;
39383 }
39384 {
39385 PyThreadState* __tstate = wxPyBeginAllowThreads();
39386 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
39387
39388 wxPyEndAllowThreads(__tstate);
39389 if (PyErr_Occurred()) SWIG_fail;
39390 }
39391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39392 return resultobj;
39393 fail:
39394 return NULL;
39395 }
39396
39397
39398 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39399 PyObject *resultobj = NULL;
39400 wxSizer *arg1 = (wxSizer *) 0 ;
39401 int arg2 ;
39402 int arg3 ;
39403 int arg4 ;
39404 PyObject *arg5 = (PyObject *) NULL ;
39405 wxSizerItem *result;
39406 PyObject * obj0 = 0 ;
39407 PyObject * obj1 = 0 ;
39408 PyObject * obj2 = 0 ;
39409 PyObject * obj3 = 0 ;
39410 PyObject * obj4 = 0 ;
39411 char *kwnames[] = {
39412 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39413 };
39414
39415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
39417 if (SWIG_arg_fail(1)) SWIG_fail;
39418 {
39419 arg2 = static_cast<int >(SWIG_As_int(obj1));
39420 if (SWIG_arg_fail(2)) SWIG_fail;
39421 }
39422 {
39423 arg3 = static_cast<int >(SWIG_As_int(obj2));
39424 if (SWIG_arg_fail(3)) SWIG_fail;
39425 }
39426 {
39427 arg4 = static_cast<int >(SWIG_As_int(obj3));
39428 if (SWIG_arg_fail(4)) SWIG_fail;
39429 }
39430 if (obj4) {
39431 arg5 = obj4;
39432 }
39433 {
39434 PyThreadState* __tstate = wxPyBeginAllowThreads();
39435 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39436
39437 wxPyEndAllowThreads(__tstate);
39438 if (PyErr_Occurred()) SWIG_fail;
39439 }
39440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39441 return resultobj;
39442 fail:
39443 return NULL;
39444 }
39445
39446
39447 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39448 PyObject *resultobj = NULL;
39449 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39450 PyObject * obj0 = 0 ;
39451 char *kwnames[] = {
39452 (char *) "self", NULL
39453 };
39454
39455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
39456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39457 if (SWIG_arg_fail(1)) SWIG_fail;
39458 {
39459 PyThreadState* __tstate = wxPyBeginAllowThreads();
39460 (arg1)->DeleteWindows();
39461
39462 wxPyEndAllowThreads(__tstate);
39463 if (PyErr_Occurred()) SWIG_fail;
39464 }
39465 Py_INCREF(Py_None); resultobj = Py_None;
39466 return resultobj;
39467 fail:
39468 return NULL;
39469 }
39470
39471
39472 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39473 PyObject *resultobj = NULL;
39474 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39475 PyObject * obj0 = 0 ;
39476 char *kwnames[] = {
39477 (char *) "self", NULL
39478 };
39479
39480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
39481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39482 if (SWIG_arg_fail(1)) SWIG_fail;
39483 {
39484 PyThreadState* __tstate = wxPyBeginAllowThreads();
39485 (arg1)->DetachSizer();
39486
39487 wxPyEndAllowThreads(__tstate);
39488 if (PyErr_Occurred()) SWIG_fail;
39489 }
39490 Py_INCREF(Py_None); resultobj = Py_None;
39491 return resultobj;
39492 fail:
39493 return NULL;
39494 }
39495
39496
39497 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39498 PyObject *resultobj = NULL;
39499 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39500 wxSize result;
39501 PyObject * obj0 = 0 ;
39502 char *kwnames[] = {
39503 (char *) "self", NULL
39504 };
39505
39506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
39507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39508 if (SWIG_arg_fail(1)) SWIG_fail;
39509 {
39510 PyThreadState* __tstate = wxPyBeginAllowThreads();
39511 result = (arg1)->GetSize();
39512
39513 wxPyEndAllowThreads(__tstate);
39514 if (PyErr_Occurred()) SWIG_fail;
39515 }
39516 {
39517 wxSize * resultptr;
39518 resultptr = new wxSize(static_cast<wxSize & >(result));
39519 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39520 }
39521 return resultobj;
39522 fail:
39523 return NULL;
39524 }
39525
39526
39527 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39528 PyObject *resultobj = NULL;
39529 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39530 wxSize result;
39531 PyObject * obj0 = 0 ;
39532 char *kwnames[] = {
39533 (char *) "self", NULL
39534 };
39535
39536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
39537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39538 if (SWIG_arg_fail(1)) SWIG_fail;
39539 {
39540 PyThreadState* __tstate = wxPyBeginAllowThreads();
39541 result = (arg1)->CalcMin();
39542
39543 wxPyEndAllowThreads(__tstate);
39544 if (PyErr_Occurred()) SWIG_fail;
39545 }
39546 {
39547 wxSize * resultptr;
39548 resultptr = new wxSize(static_cast<wxSize & >(result));
39549 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39550 }
39551 return resultobj;
39552 fail:
39553 return NULL;
39554 }
39555
39556
39557 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39558 PyObject *resultobj = NULL;
39559 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39560 wxPoint *arg2 = 0 ;
39561 wxSize *arg3 = 0 ;
39562 wxPoint temp2 ;
39563 wxSize temp3 ;
39564 PyObject * obj0 = 0 ;
39565 PyObject * obj1 = 0 ;
39566 PyObject * obj2 = 0 ;
39567 char *kwnames[] = {
39568 (char *) "self",(char *) "pos",(char *) "size", NULL
39569 };
39570
39571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
39572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39573 if (SWIG_arg_fail(1)) SWIG_fail;
39574 {
39575 arg2 = &temp2;
39576 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39577 }
39578 {
39579 arg3 = &temp3;
39580 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39581 }
39582 {
39583 PyThreadState* __tstate = wxPyBeginAllowThreads();
39584 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
39585
39586 wxPyEndAllowThreads(__tstate);
39587 if (PyErr_Occurred()) SWIG_fail;
39588 }
39589 Py_INCREF(Py_None); resultobj = Py_None;
39590 return resultobj;
39591 fail:
39592 return NULL;
39593 }
39594
39595
39596 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39597 PyObject *resultobj = NULL;
39598 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39599 wxSize result;
39600 PyObject * obj0 = 0 ;
39601 char *kwnames[] = {
39602 (char *) "self", NULL
39603 };
39604
39605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
39606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39607 if (SWIG_arg_fail(1)) SWIG_fail;
39608 {
39609 PyThreadState* __tstate = wxPyBeginAllowThreads();
39610 result = (arg1)->GetMinSize();
39611
39612 wxPyEndAllowThreads(__tstate);
39613 if (PyErr_Occurred()) SWIG_fail;
39614 }
39615 {
39616 wxSize * resultptr;
39617 resultptr = new wxSize(static_cast<wxSize & >(result));
39618 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39619 }
39620 return resultobj;
39621 fail:
39622 return NULL;
39623 }
39624
39625
39626 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39627 PyObject *resultobj = NULL;
39628 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39629 wxSize result;
39630 PyObject * obj0 = 0 ;
39631 char *kwnames[] = {
39632 (char *) "self", NULL
39633 };
39634
39635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
39636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39637 if (SWIG_arg_fail(1)) SWIG_fail;
39638 {
39639 PyThreadState* __tstate = wxPyBeginAllowThreads();
39640 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
39641
39642 wxPyEndAllowThreads(__tstate);
39643 if (PyErr_Occurred()) SWIG_fail;
39644 }
39645 {
39646 wxSize * resultptr;
39647 resultptr = new wxSize(static_cast<wxSize & >(result));
39648 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39649 }
39650 return resultobj;
39651 fail:
39652 return NULL;
39653 }
39654
39655
39656 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
39657 PyObject *resultobj = NULL;
39658 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39659 int arg2 ;
39660 int arg3 ;
39661 PyObject * obj0 = 0 ;
39662 PyObject * obj1 = 0 ;
39663 PyObject * obj2 = 0 ;
39664 char *kwnames[] = {
39665 (char *) "self",(char *) "x",(char *) "y", NULL
39666 };
39667
39668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39670 if (SWIG_arg_fail(1)) SWIG_fail;
39671 {
39672 arg2 = static_cast<int >(SWIG_As_int(obj1));
39673 if (SWIG_arg_fail(2)) SWIG_fail;
39674 }
39675 {
39676 arg3 = static_cast<int >(SWIG_As_int(obj2));
39677 if (SWIG_arg_fail(3)) SWIG_fail;
39678 }
39679 {
39680 PyThreadState* __tstate = wxPyBeginAllowThreads();
39681 (arg1)->SetInitSize(arg2,arg3);
39682
39683 wxPyEndAllowThreads(__tstate);
39684 if (PyErr_Occurred()) SWIG_fail;
39685 }
39686 Py_INCREF(Py_None); resultobj = Py_None;
39687 return resultobj;
39688 fail:
39689 return NULL;
39690 }
39691
39692
39693 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
39694 PyObject *resultobj = NULL;
39695 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39696 int arg2 ;
39697 int arg3 ;
39698 PyObject * obj0 = 0 ;
39699 PyObject * obj1 = 0 ;
39700 PyObject * obj2 = 0 ;
39701 char *kwnames[] = {
39702 (char *) "self",(char *) "width",(char *) "height", NULL
39703 };
39704
39705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
39706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39707 if (SWIG_arg_fail(1)) SWIG_fail;
39708 {
39709 arg2 = static_cast<int >(SWIG_As_int(obj1));
39710 if (SWIG_arg_fail(2)) SWIG_fail;
39711 }
39712 {
39713 arg3 = static_cast<int >(SWIG_As_int(obj2));
39714 if (SWIG_arg_fail(3)) SWIG_fail;
39715 }
39716 {
39717 PyThreadState* __tstate = wxPyBeginAllowThreads();
39718 (arg1)->SetRatio(arg2,arg3);
39719
39720 wxPyEndAllowThreads(__tstate);
39721 if (PyErr_Occurred()) SWIG_fail;
39722 }
39723 Py_INCREF(Py_None); resultobj = Py_None;
39724 return resultobj;
39725 fail:
39726 return NULL;
39727 }
39728
39729
39730 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
39731 PyObject *resultobj = NULL;
39732 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39733 wxSize *arg2 = 0 ;
39734 wxSize temp2 ;
39735 PyObject * obj0 = 0 ;
39736 PyObject * obj1 = 0 ;
39737 char *kwnames[] = {
39738 (char *) "self",(char *) "size", NULL
39739 };
39740
39741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
39742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39743 if (SWIG_arg_fail(1)) SWIG_fail;
39744 {
39745 arg2 = &temp2;
39746 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39747 }
39748 {
39749 PyThreadState* __tstate = wxPyBeginAllowThreads();
39750 (arg1)->SetRatio((wxSize const &)*arg2);
39751
39752 wxPyEndAllowThreads(__tstate);
39753 if (PyErr_Occurred()) SWIG_fail;
39754 }
39755 Py_INCREF(Py_None); resultobj = Py_None;
39756 return resultobj;
39757 fail:
39758 return NULL;
39759 }
39760
39761
39762 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39763 PyObject *resultobj = NULL;
39764 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39765 float arg2 ;
39766 PyObject * obj0 = 0 ;
39767 PyObject * obj1 = 0 ;
39768 char *kwnames[] = {
39769 (char *) "self",(char *) "ratio", NULL
39770 };
39771
39772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
39773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39774 if (SWIG_arg_fail(1)) SWIG_fail;
39775 {
39776 arg2 = static_cast<float >(SWIG_As_float(obj1));
39777 if (SWIG_arg_fail(2)) SWIG_fail;
39778 }
39779 {
39780 PyThreadState* __tstate = wxPyBeginAllowThreads();
39781 (arg1)->SetRatio(arg2);
39782
39783 wxPyEndAllowThreads(__tstate);
39784 if (PyErr_Occurred()) SWIG_fail;
39785 }
39786 Py_INCREF(Py_None); resultobj = Py_None;
39787 return resultobj;
39788 fail:
39789 return NULL;
39790 }
39791
39792
39793 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39794 PyObject *resultobj = NULL;
39795 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39796 float result;
39797 PyObject * obj0 = 0 ;
39798 char *kwnames[] = {
39799 (char *) "self", NULL
39800 };
39801
39802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",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 = (float)(arg1)->GetRatio();
39808
39809 wxPyEndAllowThreads(__tstate);
39810 if (PyErr_Occurred()) SWIG_fail;
39811 }
39812 {
39813 resultobj = SWIG_From_float(static_cast<float >(result));
39814 }
39815 return resultobj;
39816 fail:
39817 return NULL;
39818 }
39819
39820
39821 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
39822 PyObject *resultobj = NULL;
39823 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39824 wxRect result;
39825 PyObject * obj0 = 0 ;
39826 char *kwnames[] = {
39827 (char *) "self", NULL
39828 };
39829
39830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
39831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39832 if (SWIG_arg_fail(1)) SWIG_fail;
39833 {
39834 PyThreadState* __tstate = wxPyBeginAllowThreads();
39835 result = (arg1)->GetRect();
39836
39837 wxPyEndAllowThreads(__tstate);
39838 if (PyErr_Occurred()) SWIG_fail;
39839 }
39840 {
39841 wxRect * resultptr;
39842 resultptr = new wxRect(static_cast<wxRect & >(result));
39843 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39844 }
39845 return resultobj;
39846 fail:
39847 return NULL;
39848 }
39849
39850
39851 static PyObject *_wrap_SizerItem_IsWindow(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_IsWindow",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)->IsWindow();
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_IsSizer(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_IsSizer",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)->IsSizer();
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_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39908 PyObject *resultobj = NULL;
39909 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39910 bool result;
39911 PyObject * obj0 = 0 ;
39912 char *kwnames[] = {
39913 (char *) "self", NULL
39914 };
39915
39916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39918 if (SWIG_arg_fail(1)) SWIG_fail;
39919 {
39920 PyThreadState* __tstate = wxPyBeginAllowThreads();
39921 result = (bool)(arg1)->IsSpacer();
39922
39923 wxPyEndAllowThreads(__tstate);
39924 if (PyErr_Occurred()) SWIG_fail;
39925 }
39926 {
39927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39928 }
39929 return resultobj;
39930 fail:
39931 return NULL;
39932 }
39933
39934
39935 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39936 PyObject *resultobj = NULL;
39937 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39938 int arg2 ;
39939 PyObject * obj0 = 0 ;
39940 PyObject * obj1 = 0 ;
39941 char *kwnames[] = {
39942 (char *) "self",(char *) "proportion", NULL
39943 };
39944
39945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39947 if (SWIG_arg_fail(1)) SWIG_fail;
39948 {
39949 arg2 = static_cast<int >(SWIG_As_int(obj1));
39950 if (SWIG_arg_fail(2)) SWIG_fail;
39951 }
39952 {
39953 PyThreadState* __tstate = wxPyBeginAllowThreads();
39954 (arg1)->SetProportion(arg2);
39955
39956 wxPyEndAllowThreads(__tstate);
39957 if (PyErr_Occurred()) SWIG_fail;
39958 }
39959 Py_INCREF(Py_None); resultobj = Py_None;
39960 return resultobj;
39961 fail:
39962 return NULL;
39963 }
39964
39965
39966 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39967 PyObject *resultobj = NULL;
39968 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39969 int result;
39970 PyObject * obj0 = 0 ;
39971 char *kwnames[] = {
39972 (char *) "self", NULL
39973 };
39974
39975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39977 if (SWIG_arg_fail(1)) SWIG_fail;
39978 {
39979 PyThreadState* __tstate = wxPyBeginAllowThreads();
39980 result = (int)(arg1)->GetProportion();
39981
39982 wxPyEndAllowThreads(__tstate);
39983 if (PyErr_Occurred()) SWIG_fail;
39984 }
39985 {
39986 resultobj = SWIG_From_int(static_cast<int >(result));
39987 }
39988 return resultobj;
39989 fail:
39990 return NULL;
39991 }
39992
39993
39994 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39995 PyObject *resultobj = NULL;
39996 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39997 int arg2 ;
39998 PyObject * obj0 = 0 ;
39999 PyObject * obj1 = 0 ;
40000 char *kwnames[] = {
40001 (char *) "self",(char *) "flag", NULL
40002 };
40003
40004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
40005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40006 if (SWIG_arg_fail(1)) SWIG_fail;
40007 {
40008 arg2 = static_cast<int >(SWIG_As_int(obj1));
40009 if (SWIG_arg_fail(2)) SWIG_fail;
40010 }
40011 {
40012 PyThreadState* __tstate = wxPyBeginAllowThreads();
40013 (arg1)->SetFlag(arg2);
40014
40015 wxPyEndAllowThreads(__tstate);
40016 if (PyErr_Occurred()) SWIG_fail;
40017 }
40018 Py_INCREF(Py_None); resultobj = Py_None;
40019 return resultobj;
40020 fail:
40021 return NULL;
40022 }
40023
40024
40025 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
40026 PyObject *resultobj = NULL;
40027 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40028 int result;
40029 PyObject * obj0 = 0 ;
40030 char *kwnames[] = {
40031 (char *) "self", NULL
40032 };
40033
40034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
40035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40036 if (SWIG_arg_fail(1)) SWIG_fail;
40037 {
40038 PyThreadState* __tstate = wxPyBeginAllowThreads();
40039 result = (int)(arg1)->GetFlag();
40040
40041 wxPyEndAllowThreads(__tstate);
40042 if (PyErr_Occurred()) SWIG_fail;
40043 }
40044 {
40045 resultobj = SWIG_From_int(static_cast<int >(result));
40046 }
40047 return resultobj;
40048 fail:
40049 return NULL;
40050 }
40051
40052
40053 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
40054 PyObject *resultobj = NULL;
40055 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40056 int arg2 ;
40057 PyObject * obj0 = 0 ;
40058 PyObject * obj1 = 0 ;
40059 char *kwnames[] = {
40060 (char *) "self",(char *) "border", NULL
40061 };
40062
40063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
40064 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40065 if (SWIG_arg_fail(1)) SWIG_fail;
40066 {
40067 arg2 = static_cast<int >(SWIG_As_int(obj1));
40068 if (SWIG_arg_fail(2)) SWIG_fail;
40069 }
40070 {
40071 PyThreadState* __tstate = wxPyBeginAllowThreads();
40072 (arg1)->SetBorder(arg2);
40073
40074 wxPyEndAllowThreads(__tstate);
40075 if (PyErr_Occurred()) SWIG_fail;
40076 }
40077 Py_INCREF(Py_None); resultobj = Py_None;
40078 return resultobj;
40079 fail:
40080 return NULL;
40081 }
40082
40083
40084 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
40085 PyObject *resultobj = NULL;
40086 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40087 int result;
40088 PyObject * obj0 = 0 ;
40089 char *kwnames[] = {
40090 (char *) "self", NULL
40091 };
40092
40093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",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 = (int)(arg1)->GetBorder();
40099
40100 wxPyEndAllowThreads(__tstate);
40101 if (PyErr_Occurred()) SWIG_fail;
40102 }
40103 {
40104 resultobj = SWIG_From_int(static_cast<int >(result));
40105 }
40106 return resultobj;
40107 fail:
40108 return NULL;
40109 }
40110
40111
40112 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40113 PyObject *resultobj = NULL;
40114 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40115 wxWindow *result;
40116 PyObject * obj0 = 0 ;
40117 char *kwnames[] = {
40118 (char *) "self", NULL
40119 };
40120
40121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
40122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40123 if (SWIG_arg_fail(1)) SWIG_fail;
40124 {
40125 PyThreadState* __tstate = wxPyBeginAllowThreads();
40126 result = (wxWindow *)(arg1)->GetWindow();
40127
40128 wxPyEndAllowThreads(__tstate);
40129 if (PyErr_Occurred()) SWIG_fail;
40130 }
40131 {
40132 resultobj = wxPyMake_wxObject(result, 0);
40133 }
40134 return resultobj;
40135 fail:
40136 return NULL;
40137 }
40138
40139
40140 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40141 PyObject *resultobj = NULL;
40142 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40143 wxWindow *arg2 = (wxWindow *) 0 ;
40144 PyObject * obj0 = 0 ;
40145 PyObject * obj1 = 0 ;
40146 char *kwnames[] = {
40147 (char *) "self",(char *) "window", NULL
40148 };
40149
40150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40154 if (SWIG_arg_fail(2)) SWIG_fail;
40155 {
40156 PyThreadState* __tstate = wxPyBeginAllowThreads();
40157 (arg1)->SetWindow(arg2);
40158
40159 wxPyEndAllowThreads(__tstate);
40160 if (PyErr_Occurred()) SWIG_fail;
40161 }
40162 Py_INCREF(Py_None); resultobj = Py_None;
40163 return resultobj;
40164 fail:
40165 return NULL;
40166 }
40167
40168
40169 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40170 PyObject *resultobj = NULL;
40171 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40172 wxSizer *result;
40173 PyObject * obj0 = 0 ;
40174 char *kwnames[] = {
40175 (char *) "self", NULL
40176 };
40177
40178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
40179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40180 if (SWIG_arg_fail(1)) SWIG_fail;
40181 {
40182 PyThreadState* __tstate = wxPyBeginAllowThreads();
40183 result = (wxSizer *)(arg1)->GetSizer();
40184
40185 wxPyEndAllowThreads(__tstate);
40186 if (PyErr_Occurred()) SWIG_fail;
40187 }
40188 {
40189 resultobj = wxPyMake_wxObject(result, (bool)0);
40190 }
40191 return resultobj;
40192 fail:
40193 return NULL;
40194 }
40195
40196
40197 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40198 PyObject *resultobj = NULL;
40199 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40200 wxSizer *arg2 = (wxSizer *) 0 ;
40201 PyObject * obj0 = 0 ;
40202 PyObject * obj1 = 0 ;
40203 char *kwnames[] = {
40204 (char *) "self",(char *) "sizer", NULL
40205 };
40206
40207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40211 if (SWIG_arg_fail(2)) SWIG_fail;
40212 {
40213 PyThreadState* __tstate = wxPyBeginAllowThreads();
40214 (arg1)->SetSizer(arg2);
40215
40216 wxPyEndAllowThreads(__tstate);
40217 if (PyErr_Occurred()) SWIG_fail;
40218 }
40219 Py_INCREF(Py_None); resultobj = Py_None;
40220 return resultobj;
40221 fail:
40222 return NULL;
40223 }
40224
40225
40226 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40227 PyObject *resultobj = NULL;
40228 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40229 wxSize *result;
40230 PyObject * obj0 = 0 ;
40231 char *kwnames[] = {
40232 (char *) "self", NULL
40233 };
40234
40235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
40236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40237 if (SWIG_arg_fail(1)) SWIG_fail;
40238 {
40239 PyThreadState* __tstate = wxPyBeginAllowThreads();
40240 {
40241 wxSize const &_result_ref = (arg1)->GetSpacer();
40242 result = (wxSize *) &_result_ref;
40243 }
40244
40245 wxPyEndAllowThreads(__tstate);
40246 if (PyErr_Occurred()) SWIG_fail;
40247 }
40248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
40249 return resultobj;
40250 fail:
40251 return NULL;
40252 }
40253
40254
40255 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40256 PyObject *resultobj = NULL;
40257 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40258 wxSize *arg2 = 0 ;
40259 wxSize temp2 ;
40260 PyObject * obj0 = 0 ;
40261 PyObject * obj1 = 0 ;
40262 char *kwnames[] = {
40263 (char *) "self",(char *) "size", NULL
40264 };
40265
40266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
40267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40268 if (SWIG_arg_fail(1)) SWIG_fail;
40269 {
40270 arg2 = &temp2;
40271 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40272 }
40273 {
40274 PyThreadState* __tstate = wxPyBeginAllowThreads();
40275 (arg1)->SetSpacer((wxSize const &)*arg2);
40276
40277 wxPyEndAllowThreads(__tstate);
40278 if (PyErr_Occurred()) SWIG_fail;
40279 }
40280 Py_INCREF(Py_None); resultobj = Py_None;
40281 return resultobj;
40282 fail:
40283 return NULL;
40284 }
40285
40286
40287 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40288 PyObject *resultobj = NULL;
40289 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40290 bool arg2 ;
40291 PyObject * obj0 = 0 ;
40292 PyObject * obj1 = 0 ;
40293 char *kwnames[] = {
40294 (char *) "self",(char *) "show", NULL
40295 };
40296
40297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
40298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40299 if (SWIG_arg_fail(1)) SWIG_fail;
40300 {
40301 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
40302 if (SWIG_arg_fail(2)) SWIG_fail;
40303 }
40304 {
40305 PyThreadState* __tstate = wxPyBeginAllowThreads();
40306 (arg1)->Show(arg2);
40307
40308 wxPyEndAllowThreads(__tstate);
40309 if (PyErr_Occurred()) SWIG_fail;
40310 }
40311 Py_INCREF(Py_None); resultobj = Py_None;
40312 return resultobj;
40313 fail:
40314 return NULL;
40315 }
40316
40317
40318 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40319 PyObject *resultobj = NULL;
40320 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40321 bool result;
40322 PyObject * obj0 = 0 ;
40323 char *kwnames[] = {
40324 (char *) "self", NULL
40325 };
40326
40327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",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 = (bool)(arg1)->IsShown();
40333
40334 wxPyEndAllowThreads(__tstate);
40335 if (PyErr_Occurred()) SWIG_fail;
40336 }
40337 {
40338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40339 }
40340 return resultobj;
40341 fail:
40342 return NULL;
40343 }
40344
40345
40346 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40347 PyObject *resultobj = NULL;
40348 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40349 wxPoint result;
40350 PyObject * obj0 = 0 ;
40351 char *kwnames[] = {
40352 (char *) "self", NULL
40353 };
40354
40355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
40356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40357 if (SWIG_arg_fail(1)) SWIG_fail;
40358 {
40359 PyThreadState* __tstate = wxPyBeginAllowThreads();
40360 result = (arg1)->GetPosition();
40361
40362 wxPyEndAllowThreads(__tstate);
40363 if (PyErr_Occurred()) SWIG_fail;
40364 }
40365 {
40366 wxPoint * resultptr;
40367 resultptr = new wxPoint(static_cast<wxPoint & >(result));
40368 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40369 }
40370 return resultobj;
40371 fail:
40372 return NULL;
40373 }
40374
40375
40376 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40377 PyObject *resultobj = NULL;
40378 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40379 PyObject *result;
40380 PyObject * obj0 = 0 ;
40381 char *kwnames[] = {
40382 (char *) "self", NULL
40383 };
40384
40385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
40386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40387 if (SWIG_arg_fail(1)) SWIG_fail;
40388 {
40389 PyThreadState* __tstate = wxPyBeginAllowThreads();
40390 result = (PyObject *)wxSizerItem_GetUserData(arg1);
40391
40392 wxPyEndAllowThreads(__tstate);
40393 if (PyErr_Occurred()) SWIG_fail;
40394 }
40395 resultobj = result;
40396 return resultobj;
40397 fail:
40398 return NULL;
40399 }
40400
40401
40402 static PyObject *_wrap_SizerItem_SetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40403 PyObject *resultobj = NULL;
40404 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40405 PyObject *arg2 = (PyObject *) 0 ;
40406 PyObject * obj0 = 0 ;
40407 PyObject * obj1 = 0 ;
40408 char *kwnames[] = {
40409 (char *) "self",(char *) "userData", NULL
40410 };
40411
40412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) goto fail;
40413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40414 if (SWIG_arg_fail(1)) SWIG_fail;
40415 arg2 = obj1;
40416 {
40417 PyThreadState* __tstate = wxPyBeginAllowThreads();
40418 wxSizerItem_SetUserData(arg1,arg2);
40419
40420 wxPyEndAllowThreads(__tstate);
40421 if (PyErr_Occurred()) SWIG_fail;
40422 }
40423 Py_INCREF(Py_None); resultobj = Py_None;
40424 return resultobj;
40425 fail:
40426 return NULL;
40427 }
40428
40429
40430 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
40431 PyObject *obj;
40432 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40433 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
40434 Py_INCREF(obj);
40435 return Py_BuildValue((char *)"");
40436 }
40437 static PyObject *_wrap_delete_Sizer(PyObject *, PyObject *args, PyObject *kwargs) {
40438 PyObject *resultobj = NULL;
40439 wxSizer *arg1 = (wxSizer *) 0 ;
40440 PyObject * obj0 = 0 ;
40441 char *kwnames[] = {
40442 (char *) "self", NULL
40443 };
40444
40445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sizer",kwnames,&obj0)) goto fail;
40446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40447 if (SWIG_arg_fail(1)) SWIG_fail;
40448 {
40449 PyThreadState* __tstate = wxPyBeginAllowThreads();
40450 delete arg1;
40451
40452 wxPyEndAllowThreads(__tstate);
40453 if (PyErr_Occurred()) SWIG_fail;
40454 }
40455 Py_INCREF(Py_None); resultobj = Py_None;
40456 return resultobj;
40457 fail:
40458 return NULL;
40459 }
40460
40461
40462 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40463 PyObject *resultobj = NULL;
40464 wxSizer *arg1 = (wxSizer *) 0 ;
40465 PyObject *arg2 = (PyObject *) 0 ;
40466 PyObject * obj0 = 0 ;
40467 PyObject * obj1 = 0 ;
40468 char *kwnames[] = {
40469 (char *) "self",(char *) "_self", NULL
40470 };
40471
40472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
40473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40474 if (SWIG_arg_fail(1)) SWIG_fail;
40475 arg2 = obj1;
40476 {
40477 PyThreadState* __tstate = wxPyBeginAllowThreads();
40478 wxSizer__setOORInfo(arg1,arg2);
40479
40480 wxPyEndAllowThreads(__tstate);
40481 if (PyErr_Occurred()) SWIG_fail;
40482 }
40483 Py_INCREF(Py_None); resultobj = Py_None;
40484 return resultobj;
40485 fail:
40486 return NULL;
40487 }
40488
40489
40490 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
40491 PyObject *resultobj = NULL;
40492 wxSizer *arg1 = (wxSizer *) 0 ;
40493 PyObject *arg2 = (PyObject *) 0 ;
40494 int arg3 = (int) 0 ;
40495 int arg4 = (int) 0 ;
40496 int arg5 = (int) 0 ;
40497 PyObject *arg6 = (PyObject *) NULL ;
40498 wxSizerItem *result;
40499 PyObject * obj0 = 0 ;
40500 PyObject * obj1 = 0 ;
40501 PyObject * obj2 = 0 ;
40502 PyObject * obj3 = 0 ;
40503 PyObject * obj4 = 0 ;
40504 PyObject * obj5 = 0 ;
40505 char *kwnames[] = {
40506 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40507 };
40508
40509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40511 if (SWIG_arg_fail(1)) SWIG_fail;
40512 arg2 = obj1;
40513 if (obj2) {
40514 {
40515 arg3 = static_cast<int >(SWIG_As_int(obj2));
40516 if (SWIG_arg_fail(3)) SWIG_fail;
40517 }
40518 }
40519 if (obj3) {
40520 {
40521 arg4 = static_cast<int >(SWIG_As_int(obj3));
40522 if (SWIG_arg_fail(4)) SWIG_fail;
40523 }
40524 }
40525 if (obj4) {
40526 {
40527 arg5 = static_cast<int >(SWIG_As_int(obj4));
40528 if (SWIG_arg_fail(5)) SWIG_fail;
40529 }
40530 }
40531 if (obj5) {
40532 arg6 = obj5;
40533 }
40534 {
40535 PyThreadState* __tstate = wxPyBeginAllowThreads();
40536 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
40537
40538 wxPyEndAllowThreads(__tstate);
40539 if (PyErr_Occurred()) SWIG_fail;
40540 }
40541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40542 return resultobj;
40543 fail:
40544 return NULL;
40545 }
40546
40547
40548 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
40549 PyObject *resultobj = NULL;
40550 wxSizer *arg1 = (wxSizer *) 0 ;
40551 int arg2 ;
40552 PyObject *arg3 = (PyObject *) 0 ;
40553 int arg4 = (int) 0 ;
40554 int arg5 = (int) 0 ;
40555 int arg6 = (int) 0 ;
40556 PyObject *arg7 = (PyObject *) NULL ;
40557 wxSizerItem *result;
40558 PyObject * obj0 = 0 ;
40559 PyObject * obj1 = 0 ;
40560 PyObject * obj2 = 0 ;
40561 PyObject * obj3 = 0 ;
40562 PyObject * obj4 = 0 ;
40563 PyObject * obj5 = 0 ;
40564 PyObject * obj6 = 0 ;
40565 char *kwnames[] = {
40566 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40567 };
40568
40569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
40570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40571 if (SWIG_arg_fail(1)) SWIG_fail;
40572 {
40573 arg2 = static_cast<int >(SWIG_As_int(obj1));
40574 if (SWIG_arg_fail(2)) SWIG_fail;
40575 }
40576 arg3 = obj2;
40577 if (obj3) {
40578 {
40579 arg4 = static_cast<int >(SWIG_As_int(obj3));
40580 if (SWIG_arg_fail(4)) SWIG_fail;
40581 }
40582 }
40583 if (obj4) {
40584 {
40585 arg5 = static_cast<int >(SWIG_As_int(obj4));
40586 if (SWIG_arg_fail(5)) SWIG_fail;
40587 }
40588 }
40589 if (obj5) {
40590 {
40591 arg6 = static_cast<int >(SWIG_As_int(obj5));
40592 if (SWIG_arg_fail(6)) SWIG_fail;
40593 }
40594 }
40595 if (obj6) {
40596 arg7 = obj6;
40597 }
40598 {
40599 PyThreadState* __tstate = wxPyBeginAllowThreads();
40600 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
40601
40602 wxPyEndAllowThreads(__tstate);
40603 if (PyErr_Occurred()) SWIG_fail;
40604 }
40605 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40606 return resultobj;
40607 fail:
40608 return NULL;
40609 }
40610
40611
40612 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
40613 PyObject *resultobj = NULL;
40614 wxSizer *arg1 = (wxSizer *) 0 ;
40615 PyObject *arg2 = (PyObject *) 0 ;
40616 int arg3 = (int) 0 ;
40617 int arg4 = (int) 0 ;
40618 int arg5 = (int) 0 ;
40619 PyObject *arg6 = (PyObject *) NULL ;
40620 wxSizerItem *result;
40621 PyObject * obj0 = 0 ;
40622 PyObject * obj1 = 0 ;
40623 PyObject * obj2 = 0 ;
40624 PyObject * obj3 = 0 ;
40625 PyObject * obj4 = 0 ;
40626 PyObject * obj5 = 0 ;
40627 char *kwnames[] = {
40628 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40629 };
40630
40631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40633 if (SWIG_arg_fail(1)) SWIG_fail;
40634 arg2 = obj1;
40635 if (obj2) {
40636 {
40637 arg3 = static_cast<int >(SWIG_As_int(obj2));
40638 if (SWIG_arg_fail(3)) SWIG_fail;
40639 }
40640 }
40641 if (obj3) {
40642 {
40643 arg4 = static_cast<int >(SWIG_As_int(obj3));
40644 if (SWIG_arg_fail(4)) SWIG_fail;
40645 }
40646 }
40647 if (obj4) {
40648 {
40649 arg5 = static_cast<int >(SWIG_As_int(obj4));
40650 if (SWIG_arg_fail(5)) SWIG_fail;
40651 }
40652 }
40653 if (obj5) {
40654 arg6 = obj5;
40655 }
40656 {
40657 PyThreadState* __tstate = wxPyBeginAllowThreads();
40658 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
40659
40660 wxPyEndAllowThreads(__tstate);
40661 if (PyErr_Occurred()) SWIG_fail;
40662 }
40663 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40664 return resultobj;
40665 fail:
40666 return NULL;
40667 }
40668
40669
40670 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
40671 PyObject *resultobj = NULL;
40672 wxSizer *arg1 = (wxSizer *) 0 ;
40673 PyObject *arg2 = (PyObject *) 0 ;
40674 bool result;
40675 PyObject * obj0 = 0 ;
40676 PyObject * obj1 = 0 ;
40677 char *kwnames[] = {
40678 (char *) "self",(char *) "item", NULL
40679 };
40680
40681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
40682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40683 if (SWIG_arg_fail(1)) SWIG_fail;
40684 arg2 = obj1;
40685 {
40686 PyThreadState* __tstate = wxPyBeginAllowThreads();
40687 result = (bool)wxSizer_Remove(arg1,arg2);
40688
40689 wxPyEndAllowThreads(__tstate);
40690 if (PyErr_Occurred()) SWIG_fail;
40691 }
40692 {
40693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40694 }
40695 return resultobj;
40696 fail:
40697 return NULL;
40698 }
40699
40700
40701 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
40702 PyObject *resultobj = NULL;
40703 wxSizer *arg1 = (wxSizer *) 0 ;
40704 PyObject *arg2 = (PyObject *) 0 ;
40705 bool result;
40706 PyObject * obj0 = 0 ;
40707 PyObject * obj1 = 0 ;
40708 char *kwnames[] = {
40709 (char *) "self",(char *) "item", NULL
40710 };
40711
40712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
40713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40714 if (SWIG_arg_fail(1)) SWIG_fail;
40715 arg2 = obj1;
40716 {
40717 PyThreadState* __tstate = wxPyBeginAllowThreads();
40718 result = (bool)wxSizer_Detach(arg1,arg2);
40719
40720 wxPyEndAllowThreads(__tstate);
40721 if (PyErr_Occurred()) SWIG_fail;
40722 }
40723 {
40724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40725 }
40726 return resultobj;
40727 fail:
40728 return NULL;
40729 }
40730
40731
40732 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
40733 PyObject *resultobj = NULL;
40734 wxSizer *arg1 = (wxSizer *) 0 ;
40735 PyObject *arg2 = (PyObject *) 0 ;
40736 wxSizerItem *result;
40737 PyObject * obj0 = 0 ;
40738 PyObject * obj1 = 0 ;
40739 char *kwnames[] = {
40740 (char *) "self",(char *) "item", NULL
40741 };
40742
40743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
40744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40745 if (SWIG_arg_fail(1)) SWIG_fail;
40746 arg2 = obj1;
40747 {
40748 PyThreadState* __tstate = wxPyBeginAllowThreads();
40749 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
40750
40751 wxPyEndAllowThreads(__tstate);
40752 if (PyErr_Occurred()) SWIG_fail;
40753 }
40754 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40755 return resultobj;
40756 fail:
40757 return NULL;
40758 }
40759
40760
40761 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40762 PyObject *resultobj = NULL;
40763 wxSizer *arg1 = (wxSizer *) 0 ;
40764 PyObject *arg2 = (PyObject *) 0 ;
40765 wxSize *arg3 = 0 ;
40766 wxSize temp3 ;
40767 PyObject * obj0 = 0 ;
40768 PyObject * obj1 = 0 ;
40769 PyObject * obj2 = 0 ;
40770 char *kwnames[] = {
40771 (char *) "self",(char *) "item",(char *) "size", NULL
40772 };
40773
40774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
40775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40776 if (SWIG_arg_fail(1)) SWIG_fail;
40777 arg2 = obj1;
40778 {
40779 arg3 = &temp3;
40780 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
40781 }
40782 {
40783 PyThreadState* __tstate = wxPyBeginAllowThreads();
40784 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
40785
40786 wxPyEndAllowThreads(__tstate);
40787 if (PyErr_Occurred()) SWIG_fail;
40788 }
40789 Py_INCREF(Py_None); resultobj = Py_None;
40790 return resultobj;
40791 fail:
40792 return NULL;
40793 }
40794
40795
40796 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
40797 PyObject *resultobj = NULL;
40798 wxSizer *arg1 = (wxSizer *) 0 ;
40799 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40800 wxSizerItem *result;
40801 PyObject * obj0 = 0 ;
40802 PyObject * obj1 = 0 ;
40803 char *kwnames[] = {
40804 (char *) "self",(char *) "item", NULL
40805 };
40806
40807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
40808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40809 if (SWIG_arg_fail(1)) SWIG_fail;
40810 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40811 if (SWIG_arg_fail(2)) SWIG_fail;
40812 {
40813 PyThreadState* __tstate = wxPyBeginAllowThreads();
40814 result = (wxSizerItem *)(arg1)->Add(arg2);
40815
40816 wxPyEndAllowThreads(__tstate);
40817 if (PyErr_Occurred()) SWIG_fail;
40818 }
40819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40820 return resultobj;
40821 fail:
40822 return NULL;
40823 }
40824
40825
40826 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
40827 PyObject *resultobj = NULL;
40828 wxSizer *arg1 = (wxSizer *) 0 ;
40829 size_t arg2 ;
40830 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
40831 wxSizerItem *result;
40832 PyObject * obj0 = 0 ;
40833 PyObject * obj1 = 0 ;
40834 PyObject * obj2 = 0 ;
40835 char *kwnames[] = {
40836 (char *) "self",(char *) "index",(char *) "item", NULL
40837 };
40838
40839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
40840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40841 if (SWIG_arg_fail(1)) SWIG_fail;
40842 {
40843 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
40844 if (SWIG_arg_fail(2)) SWIG_fail;
40845 }
40846 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40847 if (SWIG_arg_fail(3)) SWIG_fail;
40848 {
40849 PyThreadState* __tstate = wxPyBeginAllowThreads();
40850 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
40851
40852 wxPyEndAllowThreads(__tstate);
40853 if (PyErr_Occurred()) SWIG_fail;
40854 }
40855 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40856 return resultobj;
40857 fail:
40858 return NULL;
40859 }
40860
40861
40862 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
40863 PyObject *resultobj = NULL;
40864 wxSizer *arg1 = (wxSizer *) 0 ;
40865 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40866 wxSizerItem *result;
40867 PyObject * obj0 = 0 ;
40868 PyObject * obj1 = 0 ;
40869 char *kwnames[] = {
40870 (char *) "self",(char *) "item", NULL
40871 };
40872
40873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
40874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40875 if (SWIG_arg_fail(1)) SWIG_fail;
40876 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40877 if (SWIG_arg_fail(2)) SWIG_fail;
40878 {
40879 PyThreadState* __tstate = wxPyBeginAllowThreads();
40880 result = (wxSizerItem *)(arg1)->Prepend(arg2);
40881
40882 wxPyEndAllowThreads(__tstate);
40883 if (PyErr_Occurred()) SWIG_fail;
40884 }
40885 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40886 return resultobj;
40887 fail:
40888 return NULL;
40889 }
40890
40891
40892 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
40893 PyObject *resultobj = NULL;
40894 wxSizer *arg1 = (wxSizer *) 0 ;
40895 int arg2 ;
40896 int arg3 ;
40897 int arg4 ;
40898 int arg5 ;
40899 PyObject * obj0 = 0 ;
40900 PyObject * obj1 = 0 ;
40901 PyObject * obj2 = 0 ;
40902 PyObject * obj3 = 0 ;
40903 PyObject * obj4 = 0 ;
40904 char *kwnames[] = {
40905 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40906 };
40907
40908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40910 if (SWIG_arg_fail(1)) SWIG_fail;
40911 {
40912 arg2 = static_cast<int >(SWIG_As_int(obj1));
40913 if (SWIG_arg_fail(2)) SWIG_fail;
40914 }
40915 {
40916 arg3 = static_cast<int >(SWIG_As_int(obj2));
40917 if (SWIG_arg_fail(3)) SWIG_fail;
40918 }
40919 {
40920 arg4 = static_cast<int >(SWIG_As_int(obj3));
40921 if (SWIG_arg_fail(4)) SWIG_fail;
40922 }
40923 {
40924 arg5 = static_cast<int >(SWIG_As_int(obj4));
40925 if (SWIG_arg_fail(5)) SWIG_fail;
40926 }
40927 {
40928 PyThreadState* __tstate = wxPyBeginAllowThreads();
40929 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40930
40931 wxPyEndAllowThreads(__tstate);
40932 if (PyErr_Occurred()) SWIG_fail;
40933 }
40934 Py_INCREF(Py_None); resultobj = Py_None;
40935 return resultobj;
40936 fail:
40937 return NULL;
40938 }
40939
40940
40941 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40942 PyObject *resultobj = NULL;
40943 wxSizer *arg1 = (wxSizer *) 0 ;
40944 wxSize *arg2 = 0 ;
40945 wxSize temp2 ;
40946 PyObject * obj0 = 0 ;
40947 PyObject * obj1 = 0 ;
40948 char *kwnames[] = {
40949 (char *) "self",(char *) "size", NULL
40950 };
40951
40952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40954 if (SWIG_arg_fail(1)) SWIG_fail;
40955 {
40956 arg2 = &temp2;
40957 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40958 }
40959 {
40960 PyThreadState* __tstate = wxPyBeginAllowThreads();
40961 (arg1)->SetMinSize((wxSize const &)*arg2);
40962
40963 wxPyEndAllowThreads(__tstate);
40964 if (PyErr_Occurred()) SWIG_fail;
40965 }
40966 Py_INCREF(Py_None); resultobj = Py_None;
40967 return resultobj;
40968 fail:
40969 return NULL;
40970 }
40971
40972
40973 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40974 PyObject *resultobj = NULL;
40975 wxSizer *arg1 = (wxSizer *) 0 ;
40976 wxSize result;
40977 PyObject * obj0 = 0 ;
40978 char *kwnames[] = {
40979 (char *) "self", NULL
40980 };
40981
40982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40984 if (SWIG_arg_fail(1)) SWIG_fail;
40985 {
40986 PyThreadState* __tstate = wxPyBeginAllowThreads();
40987 result = (arg1)->GetSize();
40988
40989 wxPyEndAllowThreads(__tstate);
40990 if (PyErr_Occurred()) SWIG_fail;
40991 }
40992 {
40993 wxSize * resultptr;
40994 resultptr = new wxSize(static_cast<wxSize & >(result));
40995 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40996 }
40997 return resultobj;
40998 fail:
40999 return NULL;
41000 }
41001
41002
41003 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41004 PyObject *resultobj = NULL;
41005 wxSizer *arg1 = (wxSizer *) 0 ;
41006 wxPoint result;
41007 PyObject * obj0 = 0 ;
41008 char *kwnames[] = {
41009 (char *) "self", NULL
41010 };
41011
41012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
41013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41014 if (SWIG_arg_fail(1)) SWIG_fail;
41015 {
41016 PyThreadState* __tstate = wxPyBeginAllowThreads();
41017 result = (arg1)->GetPosition();
41018
41019 wxPyEndAllowThreads(__tstate);
41020 if (PyErr_Occurred()) SWIG_fail;
41021 }
41022 {
41023 wxPoint * resultptr;
41024 resultptr = new wxPoint(static_cast<wxPoint & >(result));
41025 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
41026 }
41027 return resultobj;
41028 fail:
41029 return NULL;
41030 }
41031
41032
41033 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
41034 PyObject *resultobj = NULL;
41035 wxSizer *arg1 = (wxSizer *) 0 ;
41036 wxSize result;
41037 PyObject * obj0 = 0 ;
41038 char *kwnames[] = {
41039 (char *) "self", NULL
41040 };
41041
41042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
41043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41044 if (SWIG_arg_fail(1)) SWIG_fail;
41045 {
41046 PyThreadState* __tstate = wxPyBeginAllowThreads();
41047 result = (arg1)->GetMinSize();
41048
41049 wxPyEndAllowThreads(__tstate);
41050 if (PyErr_Occurred()) SWIG_fail;
41051 }
41052 {
41053 wxSize * resultptr;
41054 resultptr = new wxSize(static_cast<wxSize & >(result));
41055 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41056 }
41057 return resultobj;
41058 fail:
41059 return NULL;
41060 }
41061
41062
41063 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
41064 PyObject *resultobj = NULL;
41065 wxSizer *arg1 = (wxSizer *) 0 ;
41066 PyObject * obj0 = 0 ;
41067 char *kwnames[] = {
41068 (char *) "self", NULL
41069 };
41070
41071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
41072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41073 if (SWIG_arg_fail(1)) SWIG_fail;
41074 {
41075 PyThreadState* __tstate = wxPyBeginAllowThreads();
41076 (arg1)->RecalcSizes();
41077
41078 wxPyEndAllowThreads(__tstate);
41079 if (PyErr_Occurred()) SWIG_fail;
41080 }
41081 Py_INCREF(Py_None); resultobj = Py_None;
41082 return resultobj;
41083 fail:
41084 return NULL;
41085 }
41086
41087
41088 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
41089 PyObject *resultobj = NULL;
41090 wxSizer *arg1 = (wxSizer *) 0 ;
41091 wxSize result;
41092 PyObject * obj0 = 0 ;
41093 char *kwnames[] = {
41094 (char *) "self", NULL
41095 };
41096
41097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
41098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41099 if (SWIG_arg_fail(1)) SWIG_fail;
41100 {
41101 PyThreadState* __tstate = wxPyBeginAllowThreads();
41102 result = (arg1)->CalcMin();
41103
41104 wxPyEndAllowThreads(__tstate);
41105 if (PyErr_Occurred()) SWIG_fail;
41106 }
41107 {
41108 wxSize * resultptr;
41109 resultptr = new wxSize(static_cast<wxSize & >(result));
41110 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41111 }
41112 return resultobj;
41113 fail:
41114 return NULL;
41115 }
41116
41117
41118 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
41119 PyObject *resultobj = NULL;
41120 wxSizer *arg1 = (wxSizer *) 0 ;
41121 PyObject * obj0 = 0 ;
41122 char *kwnames[] = {
41123 (char *) "self", NULL
41124 };
41125
41126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
41127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41128 if (SWIG_arg_fail(1)) SWIG_fail;
41129 {
41130 PyThreadState* __tstate = wxPyBeginAllowThreads();
41131 (arg1)->Layout();
41132
41133 wxPyEndAllowThreads(__tstate);
41134 if (PyErr_Occurred()) SWIG_fail;
41135 }
41136 Py_INCREF(Py_None); resultobj = Py_None;
41137 return resultobj;
41138 fail:
41139 return NULL;
41140 }
41141
41142
41143 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
41144 PyObject *resultobj = NULL;
41145 wxSizer *arg1 = (wxSizer *) 0 ;
41146 wxWindow *arg2 = (wxWindow *) 0 ;
41147 wxSize result;
41148 PyObject * obj0 = 0 ;
41149 PyObject * obj1 = 0 ;
41150 char *kwnames[] = {
41151 (char *) "self",(char *) "window", NULL
41152 };
41153
41154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
41155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41156 if (SWIG_arg_fail(1)) SWIG_fail;
41157 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41158 if (SWIG_arg_fail(2)) SWIG_fail;
41159 {
41160 PyThreadState* __tstate = wxPyBeginAllowThreads();
41161 result = (arg1)->Fit(arg2);
41162
41163 wxPyEndAllowThreads(__tstate);
41164 if (PyErr_Occurred()) SWIG_fail;
41165 }
41166 {
41167 wxSize * resultptr;
41168 resultptr = new wxSize(static_cast<wxSize & >(result));
41169 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41170 }
41171 return resultobj;
41172 fail:
41173 return NULL;
41174 }
41175
41176
41177 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
41178 PyObject *resultobj = NULL;
41179 wxSizer *arg1 = (wxSizer *) 0 ;
41180 wxWindow *arg2 = (wxWindow *) 0 ;
41181 PyObject * obj0 = 0 ;
41182 PyObject * obj1 = 0 ;
41183 char *kwnames[] = {
41184 (char *) "self",(char *) "window", NULL
41185 };
41186
41187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
41188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41189 if (SWIG_arg_fail(1)) SWIG_fail;
41190 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41191 if (SWIG_arg_fail(2)) SWIG_fail;
41192 {
41193 PyThreadState* __tstate = wxPyBeginAllowThreads();
41194 (arg1)->FitInside(arg2);
41195
41196 wxPyEndAllowThreads(__tstate);
41197 if (PyErr_Occurred()) SWIG_fail;
41198 }
41199 Py_INCREF(Py_None); resultobj = Py_None;
41200 return resultobj;
41201 fail:
41202 return NULL;
41203 }
41204
41205
41206 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
41207 PyObject *resultobj = NULL;
41208 wxSizer *arg1 = (wxSizer *) 0 ;
41209 wxWindow *arg2 = (wxWindow *) 0 ;
41210 PyObject * obj0 = 0 ;
41211 PyObject * obj1 = 0 ;
41212 char *kwnames[] = {
41213 (char *) "self",(char *) "window", NULL
41214 };
41215
41216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
41217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41218 if (SWIG_arg_fail(1)) SWIG_fail;
41219 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41220 if (SWIG_arg_fail(2)) SWIG_fail;
41221 {
41222 PyThreadState* __tstate = wxPyBeginAllowThreads();
41223 (arg1)->SetSizeHints(arg2);
41224
41225 wxPyEndAllowThreads(__tstate);
41226 if (PyErr_Occurred()) SWIG_fail;
41227 }
41228 Py_INCREF(Py_None); resultobj = Py_None;
41229 return resultobj;
41230 fail:
41231 return NULL;
41232 }
41233
41234
41235 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
41236 PyObject *resultobj = NULL;
41237 wxSizer *arg1 = (wxSizer *) 0 ;
41238 wxWindow *arg2 = (wxWindow *) 0 ;
41239 PyObject * obj0 = 0 ;
41240 PyObject * obj1 = 0 ;
41241 char *kwnames[] = {
41242 (char *) "self",(char *) "window", NULL
41243 };
41244
41245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
41246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41247 if (SWIG_arg_fail(1)) SWIG_fail;
41248 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41249 if (SWIG_arg_fail(2)) SWIG_fail;
41250 {
41251 PyThreadState* __tstate = wxPyBeginAllowThreads();
41252 (arg1)->SetVirtualSizeHints(arg2);
41253
41254 wxPyEndAllowThreads(__tstate);
41255 if (PyErr_Occurred()) SWIG_fail;
41256 }
41257 Py_INCREF(Py_None); resultobj = Py_None;
41258 return resultobj;
41259 fail:
41260 return NULL;
41261 }
41262
41263
41264 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
41265 PyObject *resultobj = NULL;
41266 wxSizer *arg1 = (wxSizer *) 0 ;
41267 bool arg2 = (bool) false ;
41268 PyObject * obj0 = 0 ;
41269 PyObject * obj1 = 0 ;
41270 char *kwnames[] = {
41271 (char *) "self",(char *) "deleteWindows", NULL
41272 };
41273
41274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
41275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41276 if (SWIG_arg_fail(1)) SWIG_fail;
41277 if (obj1) {
41278 {
41279 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
41280 if (SWIG_arg_fail(2)) SWIG_fail;
41281 }
41282 }
41283 {
41284 PyThreadState* __tstate = wxPyBeginAllowThreads();
41285 (arg1)->Clear(arg2);
41286
41287 wxPyEndAllowThreads(__tstate);
41288 if (PyErr_Occurred()) SWIG_fail;
41289 }
41290 Py_INCREF(Py_None); resultobj = Py_None;
41291 return resultobj;
41292 fail:
41293 return NULL;
41294 }
41295
41296
41297 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
41298 PyObject *resultobj = NULL;
41299 wxSizer *arg1 = (wxSizer *) 0 ;
41300 PyObject * obj0 = 0 ;
41301 char *kwnames[] = {
41302 (char *) "self", NULL
41303 };
41304
41305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
41306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41307 if (SWIG_arg_fail(1)) SWIG_fail;
41308 {
41309 PyThreadState* __tstate = wxPyBeginAllowThreads();
41310 (arg1)->DeleteWindows();
41311
41312 wxPyEndAllowThreads(__tstate);
41313 if (PyErr_Occurred()) SWIG_fail;
41314 }
41315 Py_INCREF(Py_None); resultobj = Py_None;
41316 return resultobj;
41317 fail:
41318 return NULL;
41319 }
41320
41321
41322 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
41323 PyObject *resultobj = NULL;
41324 wxSizer *arg1 = (wxSizer *) 0 ;
41325 PyObject *result;
41326 PyObject * obj0 = 0 ;
41327 char *kwnames[] = {
41328 (char *) "self", NULL
41329 };
41330
41331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
41332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41333 if (SWIG_arg_fail(1)) SWIG_fail;
41334 {
41335 PyThreadState* __tstate = wxPyBeginAllowThreads();
41336 result = (PyObject *)wxSizer_GetChildren(arg1);
41337
41338 wxPyEndAllowThreads(__tstate);
41339 if (PyErr_Occurred()) SWIG_fail;
41340 }
41341 resultobj = result;
41342 return resultobj;
41343 fail:
41344 return NULL;
41345 }
41346
41347
41348 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
41349 PyObject *resultobj = NULL;
41350 wxSizer *arg1 = (wxSizer *) 0 ;
41351 PyObject *arg2 = (PyObject *) 0 ;
41352 bool arg3 = (bool) true ;
41353 bool arg4 = (bool) false ;
41354 bool result;
41355 PyObject * obj0 = 0 ;
41356 PyObject * obj1 = 0 ;
41357 PyObject * obj2 = 0 ;
41358 PyObject * obj3 = 0 ;
41359 char *kwnames[] = {
41360 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
41361 };
41362
41363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41365 if (SWIG_arg_fail(1)) SWIG_fail;
41366 arg2 = obj1;
41367 if (obj2) {
41368 {
41369 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
41370 if (SWIG_arg_fail(3)) SWIG_fail;
41371 }
41372 }
41373 if (obj3) {
41374 {
41375 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
41376 if (SWIG_arg_fail(4)) SWIG_fail;
41377 }
41378 }
41379 {
41380 PyThreadState* __tstate = wxPyBeginAllowThreads();
41381 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
41382
41383 wxPyEndAllowThreads(__tstate);
41384 if (PyErr_Occurred()) SWIG_fail;
41385 }
41386 {
41387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41388 }
41389 return resultobj;
41390 fail:
41391 return NULL;
41392 }
41393
41394
41395 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
41396 PyObject *resultobj = NULL;
41397 wxSizer *arg1 = (wxSizer *) 0 ;
41398 PyObject *arg2 = (PyObject *) 0 ;
41399 bool result;
41400 PyObject * obj0 = 0 ;
41401 PyObject * obj1 = 0 ;
41402 char *kwnames[] = {
41403 (char *) "self",(char *) "item", NULL
41404 };
41405
41406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
41407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41408 if (SWIG_arg_fail(1)) SWIG_fail;
41409 arg2 = obj1;
41410 {
41411 PyThreadState* __tstate = wxPyBeginAllowThreads();
41412 result = (bool)wxSizer_IsShown(arg1,arg2);
41413
41414 wxPyEndAllowThreads(__tstate);
41415 if (PyErr_Occurred()) SWIG_fail;
41416 }
41417 {
41418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41419 }
41420 return resultobj;
41421 fail:
41422 return NULL;
41423 }
41424
41425
41426 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
41427 PyObject *resultobj = NULL;
41428 wxSizer *arg1 = (wxSizer *) 0 ;
41429 bool arg2 ;
41430 PyObject * obj0 = 0 ;
41431 PyObject * obj1 = 0 ;
41432 char *kwnames[] = {
41433 (char *) "self",(char *) "show", NULL
41434 };
41435
41436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
41437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41438 if (SWIG_arg_fail(1)) SWIG_fail;
41439 {
41440 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
41441 if (SWIG_arg_fail(2)) SWIG_fail;
41442 }
41443 {
41444 PyThreadState* __tstate = wxPyBeginAllowThreads();
41445 (arg1)->ShowItems(arg2);
41446
41447 wxPyEndAllowThreads(__tstate);
41448 if (PyErr_Occurred()) SWIG_fail;
41449 }
41450 Py_INCREF(Py_None); resultobj = Py_None;
41451 return resultobj;
41452 fail:
41453 return NULL;
41454 }
41455
41456
41457 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
41458 PyObject *obj;
41459 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41460 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
41461 Py_INCREF(obj);
41462 return Py_BuildValue((char *)"");
41463 }
41464 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
41465 PyObject *resultobj = NULL;
41466 wxPySizer *result;
41467 char *kwnames[] = {
41468 NULL
41469 };
41470
41471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
41472 {
41473 PyThreadState* __tstate = wxPyBeginAllowThreads();
41474 result = (wxPySizer *)new wxPySizer();
41475
41476 wxPyEndAllowThreads(__tstate);
41477 if (PyErr_Occurred()) SWIG_fail;
41478 }
41479 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
41480 return resultobj;
41481 fail:
41482 return NULL;
41483 }
41484
41485
41486 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
41487 PyObject *resultobj = NULL;
41488 wxPySizer *arg1 = (wxPySizer *) 0 ;
41489 PyObject *arg2 = (PyObject *) 0 ;
41490 PyObject *arg3 = (PyObject *) 0 ;
41491 PyObject * obj0 = 0 ;
41492 PyObject * obj1 = 0 ;
41493 PyObject * obj2 = 0 ;
41494 char *kwnames[] = {
41495 (char *) "self",(char *) "self",(char *) "_class", NULL
41496 };
41497
41498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
41499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
41500 if (SWIG_arg_fail(1)) SWIG_fail;
41501 arg2 = obj1;
41502 arg3 = obj2;
41503 {
41504 PyThreadState* __tstate = wxPyBeginAllowThreads();
41505 (arg1)->_setCallbackInfo(arg2,arg3);
41506
41507 wxPyEndAllowThreads(__tstate);
41508 if (PyErr_Occurred()) SWIG_fail;
41509 }
41510 Py_INCREF(Py_None); resultobj = Py_None;
41511 return resultobj;
41512 fail:
41513 return NULL;
41514 }
41515
41516
41517 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
41518 PyObject *obj;
41519 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41520 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
41521 Py_INCREF(obj);
41522 return Py_BuildValue((char *)"");
41523 }
41524 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41525 PyObject *resultobj = NULL;
41526 int arg1 = (int) wxHORIZONTAL ;
41527 wxBoxSizer *result;
41528 PyObject * obj0 = 0 ;
41529 char *kwnames[] = {
41530 (char *) "orient", NULL
41531 };
41532
41533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
41534 if (obj0) {
41535 {
41536 arg1 = static_cast<int >(SWIG_As_int(obj0));
41537 if (SWIG_arg_fail(1)) SWIG_fail;
41538 }
41539 }
41540 {
41541 PyThreadState* __tstate = wxPyBeginAllowThreads();
41542 result = (wxBoxSizer *)new wxBoxSizer(arg1);
41543
41544 wxPyEndAllowThreads(__tstate);
41545 if (PyErr_Occurred()) SWIG_fail;
41546 }
41547 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
41548 return resultobj;
41549 fail:
41550 return NULL;
41551 }
41552
41553
41554 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41555 PyObject *resultobj = NULL;
41556 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41557 int result;
41558 PyObject * obj0 = 0 ;
41559 char *kwnames[] = {
41560 (char *) "self", NULL
41561 };
41562
41563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
41564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41565 if (SWIG_arg_fail(1)) SWIG_fail;
41566 {
41567 PyThreadState* __tstate = wxPyBeginAllowThreads();
41568 result = (int)(arg1)->GetOrientation();
41569
41570 wxPyEndAllowThreads(__tstate);
41571 if (PyErr_Occurred()) SWIG_fail;
41572 }
41573 {
41574 resultobj = SWIG_From_int(static_cast<int >(result));
41575 }
41576 return resultobj;
41577 fail:
41578 return NULL;
41579 }
41580
41581
41582 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41583 PyObject *resultobj = NULL;
41584 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41585 int arg2 ;
41586 PyObject * obj0 = 0 ;
41587 PyObject * obj1 = 0 ;
41588 char *kwnames[] = {
41589 (char *) "self",(char *) "orient", NULL
41590 };
41591
41592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
41593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41594 if (SWIG_arg_fail(1)) SWIG_fail;
41595 {
41596 arg2 = static_cast<int >(SWIG_As_int(obj1));
41597 if (SWIG_arg_fail(2)) SWIG_fail;
41598 }
41599 {
41600 PyThreadState* __tstate = wxPyBeginAllowThreads();
41601 (arg1)->SetOrientation(arg2);
41602
41603 wxPyEndAllowThreads(__tstate);
41604 if (PyErr_Occurred()) SWIG_fail;
41605 }
41606 Py_INCREF(Py_None); resultobj = Py_None;
41607 return resultobj;
41608 fail:
41609 return NULL;
41610 }
41611
41612
41613 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
41614 PyObject *obj;
41615 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41616 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
41617 Py_INCREF(obj);
41618 return Py_BuildValue((char *)"");
41619 }
41620 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41621 PyObject *resultobj = NULL;
41622 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
41623 int arg2 = (int) wxHORIZONTAL ;
41624 wxStaticBoxSizer *result;
41625 PyObject * obj0 = 0 ;
41626 PyObject * obj1 = 0 ;
41627 char *kwnames[] = {
41628 (char *) "box",(char *) "orient", NULL
41629 };
41630
41631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
41632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
41633 if (SWIG_arg_fail(1)) SWIG_fail;
41634 if (obj1) {
41635 {
41636 arg2 = static_cast<int >(SWIG_As_int(obj1));
41637 if (SWIG_arg_fail(2)) SWIG_fail;
41638 }
41639 }
41640 {
41641 PyThreadState* __tstate = wxPyBeginAllowThreads();
41642 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
41643
41644 wxPyEndAllowThreads(__tstate);
41645 if (PyErr_Occurred()) SWIG_fail;
41646 }
41647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
41648 return resultobj;
41649 fail:
41650 return NULL;
41651 }
41652
41653
41654 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
41655 PyObject *resultobj = NULL;
41656 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
41657 wxStaticBox *result;
41658 PyObject * obj0 = 0 ;
41659 char *kwnames[] = {
41660 (char *) "self", NULL
41661 };
41662
41663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
41664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41665 if (SWIG_arg_fail(1)) SWIG_fail;
41666 {
41667 PyThreadState* __tstate = wxPyBeginAllowThreads();
41668 result = (wxStaticBox *)(arg1)->GetStaticBox();
41669
41670 wxPyEndAllowThreads(__tstate);
41671 if (PyErr_Occurred()) SWIG_fail;
41672 }
41673 {
41674 resultobj = wxPyMake_wxObject(result, (bool)0);
41675 }
41676 return resultobj;
41677 fail:
41678 return NULL;
41679 }
41680
41681
41682 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
41683 PyObject *obj;
41684 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41685 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
41686 Py_INCREF(obj);
41687 return Py_BuildValue((char *)"");
41688 }
41689 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41690 PyObject *resultobj = NULL;
41691 int arg1 = (int) 1 ;
41692 int arg2 = (int) 0 ;
41693 int arg3 = (int) 0 ;
41694 int arg4 = (int) 0 ;
41695 wxGridSizer *result;
41696 PyObject * obj0 = 0 ;
41697 PyObject * obj1 = 0 ;
41698 PyObject * obj2 = 0 ;
41699 PyObject * obj3 = 0 ;
41700 char *kwnames[] = {
41701 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41702 };
41703
41704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41705 if (obj0) {
41706 {
41707 arg1 = static_cast<int >(SWIG_As_int(obj0));
41708 if (SWIG_arg_fail(1)) SWIG_fail;
41709 }
41710 }
41711 if (obj1) {
41712 {
41713 arg2 = static_cast<int >(SWIG_As_int(obj1));
41714 if (SWIG_arg_fail(2)) SWIG_fail;
41715 }
41716 }
41717 if (obj2) {
41718 {
41719 arg3 = static_cast<int >(SWIG_As_int(obj2));
41720 if (SWIG_arg_fail(3)) SWIG_fail;
41721 }
41722 }
41723 if (obj3) {
41724 {
41725 arg4 = static_cast<int >(SWIG_As_int(obj3));
41726 if (SWIG_arg_fail(4)) SWIG_fail;
41727 }
41728 }
41729 {
41730 PyThreadState* __tstate = wxPyBeginAllowThreads();
41731 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
41732
41733 wxPyEndAllowThreads(__tstate);
41734 if (PyErr_Occurred()) SWIG_fail;
41735 }
41736 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
41737 return resultobj;
41738 fail:
41739 return NULL;
41740 }
41741
41742
41743 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41744 PyObject *resultobj = NULL;
41745 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41746 int arg2 ;
41747 PyObject * obj0 = 0 ;
41748 PyObject * obj1 = 0 ;
41749 char *kwnames[] = {
41750 (char *) "self",(char *) "cols", NULL
41751 };
41752
41753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
41754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41755 if (SWIG_arg_fail(1)) SWIG_fail;
41756 {
41757 arg2 = static_cast<int >(SWIG_As_int(obj1));
41758 if (SWIG_arg_fail(2)) SWIG_fail;
41759 }
41760 {
41761 PyThreadState* __tstate = wxPyBeginAllowThreads();
41762 (arg1)->SetCols(arg2);
41763
41764 wxPyEndAllowThreads(__tstate);
41765 if (PyErr_Occurred()) SWIG_fail;
41766 }
41767 Py_INCREF(Py_None); resultobj = Py_None;
41768 return resultobj;
41769 fail:
41770 return NULL;
41771 }
41772
41773
41774 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41775 PyObject *resultobj = NULL;
41776 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41777 int arg2 ;
41778 PyObject * obj0 = 0 ;
41779 PyObject * obj1 = 0 ;
41780 char *kwnames[] = {
41781 (char *) "self",(char *) "rows", NULL
41782 };
41783
41784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
41785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41786 if (SWIG_arg_fail(1)) SWIG_fail;
41787 {
41788 arg2 = static_cast<int >(SWIG_As_int(obj1));
41789 if (SWIG_arg_fail(2)) SWIG_fail;
41790 }
41791 {
41792 PyThreadState* __tstate = wxPyBeginAllowThreads();
41793 (arg1)->SetRows(arg2);
41794
41795 wxPyEndAllowThreads(__tstate);
41796 if (PyErr_Occurred()) SWIG_fail;
41797 }
41798 Py_INCREF(Py_None); resultobj = Py_None;
41799 return resultobj;
41800 fail:
41801 return NULL;
41802 }
41803
41804
41805 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41806 PyObject *resultobj = NULL;
41807 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41808 int arg2 ;
41809 PyObject * obj0 = 0 ;
41810 PyObject * obj1 = 0 ;
41811 char *kwnames[] = {
41812 (char *) "self",(char *) "gap", NULL
41813 };
41814
41815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
41816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41817 if (SWIG_arg_fail(1)) SWIG_fail;
41818 {
41819 arg2 = static_cast<int >(SWIG_As_int(obj1));
41820 if (SWIG_arg_fail(2)) SWIG_fail;
41821 }
41822 {
41823 PyThreadState* __tstate = wxPyBeginAllowThreads();
41824 (arg1)->SetVGap(arg2);
41825
41826 wxPyEndAllowThreads(__tstate);
41827 if (PyErr_Occurred()) SWIG_fail;
41828 }
41829 Py_INCREF(Py_None); resultobj = Py_None;
41830 return resultobj;
41831 fail:
41832 return NULL;
41833 }
41834
41835
41836 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41837 PyObject *resultobj = NULL;
41838 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41839 int arg2 ;
41840 PyObject * obj0 = 0 ;
41841 PyObject * obj1 = 0 ;
41842 char *kwnames[] = {
41843 (char *) "self",(char *) "gap", NULL
41844 };
41845
41846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
41847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41848 if (SWIG_arg_fail(1)) SWIG_fail;
41849 {
41850 arg2 = static_cast<int >(SWIG_As_int(obj1));
41851 if (SWIG_arg_fail(2)) SWIG_fail;
41852 }
41853 {
41854 PyThreadState* __tstate = wxPyBeginAllowThreads();
41855 (arg1)->SetHGap(arg2);
41856
41857 wxPyEndAllowThreads(__tstate);
41858 if (PyErr_Occurred()) SWIG_fail;
41859 }
41860 Py_INCREF(Py_None); resultobj = Py_None;
41861 return resultobj;
41862 fail:
41863 return NULL;
41864 }
41865
41866
41867 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41868 PyObject *resultobj = NULL;
41869 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41870 int result;
41871 PyObject * obj0 = 0 ;
41872 char *kwnames[] = {
41873 (char *) "self", NULL
41874 };
41875
41876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
41877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41878 if (SWIG_arg_fail(1)) SWIG_fail;
41879 {
41880 PyThreadState* __tstate = wxPyBeginAllowThreads();
41881 result = (int)(arg1)->GetCols();
41882
41883 wxPyEndAllowThreads(__tstate);
41884 if (PyErr_Occurred()) SWIG_fail;
41885 }
41886 {
41887 resultobj = SWIG_From_int(static_cast<int >(result));
41888 }
41889 return resultobj;
41890 fail:
41891 return NULL;
41892 }
41893
41894
41895 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41896 PyObject *resultobj = NULL;
41897 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41898 int result;
41899 PyObject * obj0 = 0 ;
41900 char *kwnames[] = {
41901 (char *) "self", NULL
41902 };
41903
41904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41906 if (SWIG_arg_fail(1)) SWIG_fail;
41907 {
41908 PyThreadState* __tstate = wxPyBeginAllowThreads();
41909 result = (int)(arg1)->GetRows();
41910
41911 wxPyEndAllowThreads(__tstate);
41912 if (PyErr_Occurred()) SWIG_fail;
41913 }
41914 {
41915 resultobj = SWIG_From_int(static_cast<int >(result));
41916 }
41917 return resultobj;
41918 fail:
41919 return NULL;
41920 }
41921
41922
41923 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41924 PyObject *resultobj = NULL;
41925 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41926 int result;
41927 PyObject * obj0 = 0 ;
41928 char *kwnames[] = {
41929 (char *) "self", NULL
41930 };
41931
41932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41934 if (SWIG_arg_fail(1)) SWIG_fail;
41935 {
41936 PyThreadState* __tstate = wxPyBeginAllowThreads();
41937 result = (int)(arg1)->GetVGap();
41938
41939 wxPyEndAllowThreads(__tstate);
41940 if (PyErr_Occurred()) SWIG_fail;
41941 }
41942 {
41943 resultobj = SWIG_From_int(static_cast<int >(result));
41944 }
41945 return resultobj;
41946 fail:
41947 return NULL;
41948 }
41949
41950
41951 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41952 PyObject *resultobj = NULL;
41953 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41954 int result;
41955 PyObject * obj0 = 0 ;
41956 char *kwnames[] = {
41957 (char *) "self", NULL
41958 };
41959
41960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41962 if (SWIG_arg_fail(1)) SWIG_fail;
41963 {
41964 PyThreadState* __tstate = wxPyBeginAllowThreads();
41965 result = (int)(arg1)->GetHGap();
41966
41967 wxPyEndAllowThreads(__tstate);
41968 if (PyErr_Occurred()) SWIG_fail;
41969 }
41970 {
41971 resultobj = SWIG_From_int(static_cast<int >(result));
41972 }
41973 return resultobj;
41974 fail:
41975 return NULL;
41976 }
41977
41978
41979 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41980 PyObject *obj;
41981 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41982 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41983 Py_INCREF(obj);
41984 return Py_BuildValue((char *)"");
41985 }
41986 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41987 PyObject *resultobj = NULL;
41988 int arg1 = (int) 1 ;
41989 int arg2 = (int) 0 ;
41990 int arg3 = (int) 0 ;
41991 int arg4 = (int) 0 ;
41992 wxFlexGridSizer *result;
41993 PyObject * obj0 = 0 ;
41994 PyObject * obj1 = 0 ;
41995 PyObject * obj2 = 0 ;
41996 PyObject * obj3 = 0 ;
41997 char *kwnames[] = {
41998 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41999 };
42000
42001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42002 if (obj0) {
42003 {
42004 arg1 = static_cast<int >(SWIG_As_int(obj0));
42005 if (SWIG_arg_fail(1)) SWIG_fail;
42006 }
42007 }
42008 if (obj1) {
42009 {
42010 arg2 = static_cast<int >(SWIG_As_int(obj1));
42011 if (SWIG_arg_fail(2)) SWIG_fail;
42012 }
42013 }
42014 if (obj2) {
42015 {
42016 arg3 = static_cast<int >(SWIG_As_int(obj2));
42017 if (SWIG_arg_fail(3)) SWIG_fail;
42018 }
42019 }
42020 if (obj3) {
42021 {
42022 arg4 = static_cast<int >(SWIG_As_int(obj3));
42023 if (SWIG_arg_fail(4)) SWIG_fail;
42024 }
42025 }
42026 {
42027 PyThreadState* __tstate = wxPyBeginAllowThreads();
42028 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
42029
42030 wxPyEndAllowThreads(__tstate);
42031 if (PyErr_Occurred()) SWIG_fail;
42032 }
42033 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
42034 return resultobj;
42035 fail:
42036 return NULL;
42037 }
42038
42039
42040 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
42041 PyObject *resultobj = NULL;
42042 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42043 size_t arg2 ;
42044 int arg3 = (int) 0 ;
42045 PyObject * obj0 = 0 ;
42046 PyObject * obj1 = 0 ;
42047 PyObject * obj2 = 0 ;
42048 char *kwnames[] = {
42049 (char *) "self",(char *) "idx",(char *) "proportion", NULL
42050 };
42051
42052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
42053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42054 if (SWIG_arg_fail(1)) SWIG_fail;
42055 {
42056 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42057 if (SWIG_arg_fail(2)) SWIG_fail;
42058 }
42059 if (obj2) {
42060 {
42061 arg3 = static_cast<int >(SWIG_As_int(obj2));
42062 if (SWIG_arg_fail(3)) SWIG_fail;
42063 }
42064 }
42065 {
42066 PyThreadState* __tstate = wxPyBeginAllowThreads();
42067 (arg1)->AddGrowableRow(arg2,arg3);
42068
42069 wxPyEndAllowThreads(__tstate);
42070 if (PyErr_Occurred()) SWIG_fail;
42071 }
42072 Py_INCREF(Py_None); resultobj = Py_None;
42073 return resultobj;
42074 fail:
42075 return NULL;
42076 }
42077
42078
42079 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
42080 PyObject *resultobj = NULL;
42081 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42082 size_t arg2 ;
42083 PyObject * obj0 = 0 ;
42084 PyObject * obj1 = 0 ;
42085 char *kwnames[] = {
42086 (char *) "self",(char *) "idx", NULL
42087 };
42088
42089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
42090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42091 if (SWIG_arg_fail(1)) SWIG_fail;
42092 {
42093 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42094 if (SWIG_arg_fail(2)) SWIG_fail;
42095 }
42096 {
42097 PyThreadState* __tstate = wxPyBeginAllowThreads();
42098 (arg1)->RemoveGrowableRow(arg2);
42099
42100 wxPyEndAllowThreads(__tstate);
42101 if (PyErr_Occurred()) SWIG_fail;
42102 }
42103 Py_INCREF(Py_None); resultobj = Py_None;
42104 return resultobj;
42105 fail:
42106 return NULL;
42107 }
42108
42109
42110 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
42111 PyObject *resultobj = NULL;
42112 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42113 size_t arg2 ;
42114 int arg3 = (int) 0 ;
42115 PyObject * obj0 = 0 ;
42116 PyObject * obj1 = 0 ;
42117 PyObject * obj2 = 0 ;
42118 char *kwnames[] = {
42119 (char *) "self",(char *) "idx",(char *) "proportion", NULL
42120 };
42121
42122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
42123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42124 if (SWIG_arg_fail(1)) SWIG_fail;
42125 {
42126 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42127 if (SWIG_arg_fail(2)) SWIG_fail;
42128 }
42129 if (obj2) {
42130 {
42131 arg3 = static_cast<int >(SWIG_As_int(obj2));
42132 if (SWIG_arg_fail(3)) SWIG_fail;
42133 }
42134 }
42135 {
42136 PyThreadState* __tstate = wxPyBeginAllowThreads();
42137 (arg1)->AddGrowableCol(arg2,arg3);
42138
42139 wxPyEndAllowThreads(__tstate);
42140 if (PyErr_Occurred()) SWIG_fail;
42141 }
42142 Py_INCREF(Py_None); resultobj = Py_None;
42143 return resultobj;
42144 fail:
42145 return NULL;
42146 }
42147
42148
42149 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
42150 PyObject *resultobj = NULL;
42151 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42152 size_t arg2 ;
42153 PyObject * obj0 = 0 ;
42154 PyObject * obj1 = 0 ;
42155 char *kwnames[] = {
42156 (char *) "self",(char *) "idx", NULL
42157 };
42158
42159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
42160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42161 if (SWIG_arg_fail(1)) SWIG_fail;
42162 {
42163 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42164 if (SWIG_arg_fail(2)) SWIG_fail;
42165 }
42166 {
42167 PyThreadState* __tstate = wxPyBeginAllowThreads();
42168 (arg1)->RemoveGrowableCol(arg2);
42169
42170 wxPyEndAllowThreads(__tstate);
42171 if (PyErr_Occurred()) SWIG_fail;
42172 }
42173 Py_INCREF(Py_None); resultobj = Py_None;
42174 return resultobj;
42175 fail:
42176 return NULL;
42177 }
42178
42179
42180 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
42181 PyObject *resultobj = NULL;
42182 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42183 int arg2 ;
42184 PyObject * obj0 = 0 ;
42185 PyObject * obj1 = 0 ;
42186 char *kwnames[] = {
42187 (char *) "self",(char *) "direction", NULL
42188 };
42189
42190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
42191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42192 if (SWIG_arg_fail(1)) SWIG_fail;
42193 {
42194 arg2 = static_cast<int >(SWIG_As_int(obj1));
42195 if (SWIG_arg_fail(2)) SWIG_fail;
42196 }
42197 {
42198 PyThreadState* __tstate = wxPyBeginAllowThreads();
42199 (arg1)->SetFlexibleDirection(arg2);
42200
42201 wxPyEndAllowThreads(__tstate);
42202 if (PyErr_Occurred()) SWIG_fail;
42203 }
42204 Py_INCREF(Py_None); resultobj = Py_None;
42205 return resultobj;
42206 fail:
42207 return NULL;
42208 }
42209
42210
42211 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
42212 PyObject *resultobj = NULL;
42213 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42214 int result;
42215 PyObject * obj0 = 0 ;
42216 char *kwnames[] = {
42217 (char *) "self", NULL
42218 };
42219
42220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
42221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42222 if (SWIG_arg_fail(1)) SWIG_fail;
42223 {
42224 PyThreadState* __tstate = wxPyBeginAllowThreads();
42225 result = (int)(arg1)->GetFlexibleDirection();
42226
42227 wxPyEndAllowThreads(__tstate);
42228 if (PyErr_Occurred()) SWIG_fail;
42229 }
42230 {
42231 resultobj = SWIG_From_int(static_cast<int >(result));
42232 }
42233 return resultobj;
42234 fail:
42235 return NULL;
42236 }
42237
42238
42239 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
42240 PyObject *resultobj = NULL;
42241 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42242 wxFlexSizerGrowMode arg2 ;
42243 PyObject * obj0 = 0 ;
42244 PyObject * obj1 = 0 ;
42245 char *kwnames[] = {
42246 (char *) "self",(char *) "mode", NULL
42247 };
42248
42249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
42250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42251 if (SWIG_arg_fail(1)) SWIG_fail;
42252 {
42253 arg2 = static_cast<wxFlexSizerGrowMode >(SWIG_As_int(obj1));
42254 if (SWIG_arg_fail(2)) SWIG_fail;
42255 }
42256 {
42257 PyThreadState* __tstate = wxPyBeginAllowThreads();
42258 (arg1)->SetNonFlexibleGrowMode(arg2);
42259
42260 wxPyEndAllowThreads(__tstate);
42261 if (PyErr_Occurred()) SWIG_fail;
42262 }
42263 Py_INCREF(Py_None); resultobj = Py_None;
42264 return resultobj;
42265 fail:
42266 return NULL;
42267 }
42268
42269
42270 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
42271 PyObject *resultobj = NULL;
42272 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42273 wxFlexSizerGrowMode result;
42274 PyObject * obj0 = 0 ;
42275 char *kwnames[] = {
42276 (char *) "self", NULL
42277 };
42278
42279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
42280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42281 if (SWIG_arg_fail(1)) SWIG_fail;
42282 {
42283 PyThreadState* __tstate = wxPyBeginAllowThreads();
42284 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
42285
42286 wxPyEndAllowThreads(__tstate);
42287 if (PyErr_Occurred()) SWIG_fail;
42288 }
42289 resultobj = SWIG_From_int((result));
42290 return resultobj;
42291 fail:
42292 return NULL;
42293 }
42294
42295
42296 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
42297 PyObject *resultobj = NULL;
42298 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42299 wxArrayInt *result;
42300 PyObject * obj0 = 0 ;
42301 char *kwnames[] = {
42302 (char *) "self", NULL
42303 };
42304
42305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
42306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42307 if (SWIG_arg_fail(1)) SWIG_fail;
42308 {
42309 PyThreadState* __tstate = wxPyBeginAllowThreads();
42310 {
42311 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
42312 result = (wxArrayInt *) &_result_ref;
42313 }
42314
42315 wxPyEndAllowThreads(__tstate);
42316 if (PyErr_Occurred()) SWIG_fail;
42317 }
42318 {
42319 resultobj = PyList_New(0);
42320 size_t idx;
42321 for (idx = 0; idx < result->GetCount(); idx += 1) {
42322 PyObject* val = PyInt_FromLong( result->Item(idx) );
42323 PyList_Append(resultobj, val);
42324 Py_DECREF(val);
42325 }
42326 }
42327 return resultobj;
42328 fail:
42329 return NULL;
42330 }
42331
42332
42333 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
42334 PyObject *resultobj = NULL;
42335 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42336 wxArrayInt *result;
42337 PyObject * obj0 = 0 ;
42338 char *kwnames[] = {
42339 (char *) "self", NULL
42340 };
42341
42342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
42343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42344 if (SWIG_arg_fail(1)) SWIG_fail;
42345 {
42346 PyThreadState* __tstate = wxPyBeginAllowThreads();
42347 {
42348 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
42349 result = (wxArrayInt *) &_result_ref;
42350 }
42351
42352 wxPyEndAllowThreads(__tstate);
42353 if (PyErr_Occurred()) SWIG_fail;
42354 }
42355 {
42356 resultobj = PyList_New(0);
42357 size_t idx;
42358 for (idx = 0; idx < result->GetCount(); idx += 1) {
42359 PyObject* val = PyInt_FromLong( result->Item(idx) );
42360 PyList_Append(resultobj, val);
42361 Py_DECREF(val);
42362 }
42363 }
42364 return resultobj;
42365 fail:
42366 return NULL;
42367 }
42368
42369
42370 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
42371 PyObject *obj;
42372 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42373 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
42374 Py_INCREF(obj);
42375 return Py_BuildValue((char *)"");
42376 }
42377 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42378 PyObject *resultobj = NULL;
42379 wxStdDialogButtonSizer *result;
42380 char *kwnames[] = {
42381 NULL
42382 };
42383
42384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
42385 {
42386 PyThreadState* __tstate = wxPyBeginAllowThreads();
42387 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
42388
42389 wxPyEndAllowThreads(__tstate);
42390 if (PyErr_Occurred()) SWIG_fail;
42391 }
42392 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
42393 return resultobj;
42394 fail:
42395 return NULL;
42396 }
42397
42398
42399 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
42400 PyObject *resultobj = NULL;
42401 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42402 wxButton *arg2 = (wxButton *) 0 ;
42403 PyObject * obj0 = 0 ;
42404 PyObject * obj1 = 0 ;
42405 char *kwnames[] = {
42406 (char *) "self",(char *) "button", NULL
42407 };
42408
42409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
42410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42411 if (SWIG_arg_fail(1)) SWIG_fail;
42412 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42413 if (SWIG_arg_fail(2)) SWIG_fail;
42414 {
42415 PyThreadState* __tstate = wxPyBeginAllowThreads();
42416 (arg1)->AddButton(arg2);
42417
42418 wxPyEndAllowThreads(__tstate);
42419 if (PyErr_Occurred()) SWIG_fail;
42420 }
42421 Py_INCREF(Py_None); resultobj = Py_None;
42422 return resultobj;
42423 fail:
42424 return NULL;
42425 }
42426
42427
42428 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
42429 PyObject *resultobj = NULL;
42430 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42431 PyObject * obj0 = 0 ;
42432 char *kwnames[] = {
42433 (char *) "self", NULL
42434 };
42435
42436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
42437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42438 if (SWIG_arg_fail(1)) SWIG_fail;
42439 {
42440 PyThreadState* __tstate = wxPyBeginAllowThreads();
42441 (arg1)->Realize();
42442
42443 wxPyEndAllowThreads(__tstate);
42444 if (PyErr_Occurred()) SWIG_fail;
42445 }
42446 Py_INCREF(Py_None); resultobj = Py_None;
42447 return resultobj;
42448 fail:
42449 return NULL;
42450 }
42451
42452
42453 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42454 PyObject *resultobj = NULL;
42455 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42456 wxButton *arg2 = (wxButton *) 0 ;
42457 PyObject * obj0 = 0 ;
42458 PyObject * obj1 = 0 ;
42459 char *kwnames[] = {
42460 (char *) "self",(char *) "button", NULL
42461 };
42462
42463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
42464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42465 if (SWIG_arg_fail(1)) SWIG_fail;
42466 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42467 if (SWIG_arg_fail(2)) SWIG_fail;
42468 {
42469 PyThreadState* __tstate = wxPyBeginAllowThreads();
42470 (arg1)->SetAffirmativeButton(arg2);
42471
42472 wxPyEndAllowThreads(__tstate);
42473 if (PyErr_Occurred()) SWIG_fail;
42474 }
42475 Py_INCREF(Py_None); resultobj = Py_None;
42476 return resultobj;
42477 fail:
42478 return NULL;
42479 }
42480
42481
42482 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42483 PyObject *resultobj = NULL;
42484 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42485 wxButton *arg2 = (wxButton *) 0 ;
42486 PyObject * obj0 = 0 ;
42487 PyObject * obj1 = 0 ;
42488 char *kwnames[] = {
42489 (char *) "self",(char *) "button", NULL
42490 };
42491
42492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
42493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42494 if (SWIG_arg_fail(1)) SWIG_fail;
42495 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42496 if (SWIG_arg_fail(2)) SWIG_fail;
42497 {
42498 PyThreadState* __tstate = wxPyBeginAllowThreads();
42499 (arg1)->SetNegativeButton(arg2);
42500
42501 wxPyEndAllowThreads(__tstate);
42502 if (PyErr_Occurred()) SWIG_fail;
42503 }
42504 Py_INCREF(Py_None); resultobj = Py_None;
42505 return resultobj;
42506 fail:
42507 return NULL;
42508 }
42509
42510
42511 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42512 PyObject *resultobj = NULL;
42513 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42514 wxButton *arg2 = (wxButton *) 0 ;
42515 PyObject * obj0 = 0 ;
42516 PyObject * obj1 = 0 ;
42517 char *kwnames[] = {
42518 (char *) "self",(char *) "button", NULL
42519 };
42520
42521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
42522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42523 if (SWIG_arg_fail(1)) SWIG_fail;
42524 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42525 if (SWIG_arg_fail(2)) SWIG_fail;
42526 {
42527 PyThreadState* __tstate = wxPyBeginAllowThreads();
42528 (arg1)->SetCancelButton(arg2);
42529
42530 wxPyEndAllowThreads(__tstate);
42531 if (PyErr_Occurred()) SWIG_fail;
42532 }
42533 Py_INCREF(Py_None); resultobj = Py_None;
42534 return resultobj;
42535 fail:
42536 return NULL;
42537 }
42538
42539
42540 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42541 PyObject *resultobj = NULL;
42542 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42543 wxButton *result;
42544 PyObject * obj0 = 0 ;
42545 char *kwnames[] = {
42546 (char *) "self", NULL
42547 };
42548
42549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
42550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42551 if (SWIG_arg_fail(1)) SWIG_fail;
42552 {
42553 PyThreadState* __tstate = wxPyBeginAllowThreads();
42554 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
42555
42556 wxPyEndAllowThreads(__tstate);
42557 if (PyErr_Occurred()) SWIG_fail;
42558 }
42559 {
42560 resultobj = wxPyMake_wxObject(result, (bool)0);
42561 }
42562 return resultobj;
42563 fail:
42564 return NULL;
42565 }
42566
42567
42568 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
42569 PyObject *resultobj = NULL;
42570 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42571 wxButton *result;
42572 PyObject * obj0 = 0 ;
42573 char *kwnames[] = {
42574 (char *) "self", NULL
42575 };
42576
42577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
42578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42579 if (SWIG_arg_fail(1)) SWIG_fail;
42580 {
42581 PyThreadState* __tstate = wxPyBeginAllowThreads();
42582 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
42583
42584 wxPyEndAllowThreads(__tstate);
42585 if (PyErr_Occurred()) SWIG_fail;
42586 }
42587 {
42588 resultobj = wxPyMake_wxObject(result, (bool)0);
42589 }
42590 return resultobj;
42591 fail:
42592 return NULL;
42593 }
42594
42595
42596 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42597 PyObject *resultobj = NULL;
42598 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42599 wxButton *result;
42600 PyObject * obj0 = 0 ;
42601 char *kwnames[] = {
42602 (char *) "self", NULL
42603 };
42604
42605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
42606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42607 if (SWIG_arg_fail(1)) SWIG_fail;
42608 {
42609 PyThreadState* __tstate = wxPyBeginAllowThreads();
42610 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
42611
42612 wxPyEndAllowThreads(__tstate);
42613 if (PyErr_Occurred()) SWIG_fail;
42614 }
42615 {
42616 resultobj = wxPyMake_wxObject(result, (bool)0);
42617 }
42618 return resultobj;
42619 fail:
42620 return NULL;
42621 }
42622
42623
42624 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42625 PyObject *resultobj = NULL;
42626 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42627 wxButton *result;
42628 PyObject * obj0 = 0 ;
42629 char *kwnames[] = {
42630 (char *) "self", NULL
42631 };
42632
42633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
42634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42635 if (SWIG_arg_fail(1)) SWIG_fail;
42636 {
42637 PyThreadState* __tstate = wxPyBeginAllowThreads();
42638 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
42639
42640 wxPyEndAllowThreads(__tstate);
42641 if (PyErr_Occurred()) SWIG_fail;
42642 }
42643 {
42644 resultobj = wxPyMake_wxObject(result, (bool)0);
42645 }
42646 return resultobj;
42647 fail:
42648 return NULL;
42649 }
42650
42651
42652 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
42653 PyObject *resultobj = NULL;
42654 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42655 wxButton *result;
42656 PyObject * obj0 = 0 ;
42657 char *kwnames[] = {
42658 (char *) "self", NULL
42659 };
42660
42661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
42662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42663 if (SWIG_arg_fail(1)) SWIG_fail;
42664 {
42665 PyThreadState* __tstate = wxPyBeginAllowThreads();
42666 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
42667
42668 wxPyEndAllowThreads(__tstate);
42669 if (PyErr_Occurred()) SWIG_fail;
42670 }
42671 {
42672 resultobj = wxPyMake_wxObject(result, (bool)0);
42673 }
42674 return resultobj;
42675 fail:
42676 return NULL;
42677 }
42678
42679
42680 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
42681 PyObject *obj;
42682 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42683 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
42684 Py_INCREF(obj);
42685 return Py_BuildValue((char *)"");
42686 }
42687 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42688 PyObject *resultobj = NULL;
42689 int arg1 = (int) 0 ;
42690 int arg2 = (int) 0 ;
42691 wxGBPosition *result;
42692 PyObject * obj0 = 0 ;
42693 PyObject * obj1 = 0 ;
42694 char *kwnames[] = {
42695 (char *) "row",(char *) "col", NULL
42696 };
42697
42698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
42699 if (obj0) {
42700 {
42701 arg1 = static_cast<int >(SWIG_As_int(obj0));
42702 if (SWIG_arg_fail(1)) SWIG_fail;
42703 }
42704 }
42705 if (obj1) {
42706 {
42707 arg2 = static_cast<int >(SWIG_As_int(obj1));
42708 if (SWIG_arg_fail(2)) SWIG_fail;
42709 }
42710 }
42711 {
42712 PyThreadState* __tstate = wxPyBeginAllowThreads();
42713 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
42714
42715 wxPyEndAllowThreads(__tstate);
42716 if (PyErr_Occurred()) SWIG_fail;
42717 }
42718 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
42719 return resultobj;
42720 fail:
42721 return NULL;
42722 }
42723
42724
42725 static PyObject *_wrap_delete_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42726 PyObject *resultobj = NULL;
42727 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42728 PyObject * obj0 = 0 ;
42729 char *kwnames[] = {
42730 (char *) "self", NULL
42731 };
42732
42733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GBPosition",kwnames,&obj0)) goto fail;
42734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42735 if (SWIG_arg_fail(1)) SWIG_fail;
42736 {
42737 PyThreadState* __tstate = wxPyBeginAllowThreads();
42738 delete arg1;
42739
42740 wxPyEndAllowThreads(__tstate);
42741 if (PyErr_Occurred()) SWIG_fail;
42742 }
42743 Py_INCREF(Py_None); resultobj = Py_None;
42744 return resultobj;
42745 fail:
42746 return NULL;
42747 }
42748
42749
42750 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42751 PyObject *resultobj = NULL;
42752 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42753 int result;
42754 PyObject * obj0 = 0 ;
42755 char *kwnames[] = {
42756 (char *) "self", NULL
42757 };
42758
42759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
42760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42761 if (SWIG_arg_fail(1)) SWIG_fail;
42762 {
42763 PyThreadState* __tstate = wxPyBeginAllowThreads();
42764 result = (int)((wxGBPosition const *)arg1)->GetRow();
42765
42766 wxPyEndAllowThreads(__tstate);
42767 if (PyErr_Occurred()) SWIG_fail;
42768 }
42769 {
42770 resultobj = SWIG_From_int(static_cast<int >(result));
42771 }
42772 return resultobj;
42773 fail:
42774 return NULL;
42775 }
42776
42777
42778 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42779 PyObject *resultobj = NULL;
42780 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42781 int result;
42782 PyObject * obj0 = 0 ;
42783 char *kwnames[] = {
42784 (char *) "self", NULL
42785 };
42786
42787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
42788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42789 if (SWIG_arg_fail(1)) SWIG_fail;
42790 {
42791 PyThreadState* __tstate = wxPyBeginAllowThreads();
42792 result = (int)((wxGBPosition const *)arg1)->GetCol();
42793
42794 wxPyEndAllowThreads(__tstate);
42795 if (PyErr_Occurred()) SWIG_fail;
42796 }
42797 {
42798 resultobj = SWIG_From_int(static_cast<int >(result));
42799 }
42800 return resultobj;
42801 fail:
42802 return NULL;
42803 }
42804
42805
42806 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42807 PyObject *resultobj = NULL;
42808 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42809 int arg2 ;
42810 PyObject * obj0 = 0 ;
42811 PyObject * obj1 = 0 ;
42812 char *kwnames[] = {
42813 (char *) "self",(char *) "row", NULL
42814 };
42815
42816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
42817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42818 if (SWIG_arg_fail(1)) SWIG_fail;
42819 {
42820 arg2 = static_cast<int >(SWIG_As_int(obj1));
42821 if (SWIG_arg_fail(2)) SWIG_fail;
42822 }
42823 {
42824 PyThreadState* __tstate = wxPyBeginAllowThreads();
42825 (arg1)->SetRow(arg2);
42826
42827 wxPyEndAllowThreads(__tstate);
42828 if (PyErr_Occurred()) SWIG_fail;
42829 }
42830 Py_INCREF(Py_None); resultobj = Py_None;
42831 return resultobj;
42832 fail:
42833 return NULL;
42834 }
42835
42836
42837 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42838 PyObject *resultobj = NULL;
42839 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42840 int arg2 ;
42841 PyObject * obj0 = 0 ;
42842 PyObject * obj1 = 0 ;
42843 char *kwnames[] = {
42844 (char *) "self",(char *) "col", NULL
42845 };
42846
42847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
42848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42849 if (SWIG_arg_fail(1)) SWIG_fail;
42850 {
42851 arg2 = static_cast<int >(SWIG_As_int(obj1));
42852 if (SWIG_arg_fail(2)) SWIG_fail;
42853 }
42854 {
42855 PyThreadState* __tstate = wxPyBeginAllowThreads();
42856 (arg1)->SetCol(arg2);
42857
42858 wxPyEndAllowThreads(__tstate);
42859 if (PyErr_Occurred()) SWIG_fail;
42860 }
42861 Py_INCREF(Py_None); resultobj = Py_None;
42862 return resultobj;
42863 fail:
42864 return NULL;
42865 }
42866
42867
42868 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42869 PyObject *resultobj = NULL;
42870 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42871 wxGBPosition *arg2 = 0 ;
42872 bool result;
42873 wxGBPosition temp2 ;
42874 PyObject * obj0 = 0 ;
42875 PyObject * obj1 = 0 ;
42876 char *kwnames[] = {
42877 (char *) "self",(char *) "other", NULL
42878 };
42879
42880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
42881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42882 if (SWIG_arg_fail(1)) SWIG_fail;
42883 {
42884 arg2 = &temp2;
42885 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42886 }
42887 {
42888 PyThreadState* __tstate = wxPyBeginAllowThreads();
42889 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
42890
42891 wxPyEndAllowThreads(__tstate);
42892 if (PyErr_Occurred()) SWIG_fail;
42893 }
42894 {
42895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42896 }
42897 return resultobj;
42898 fail:
42899 return NULL;
42900 }
42901
42902
42903 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42904 PyObject *resultobj = NULL;
42905 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42906 wxGBPosition *arg2 = 0 ;
42907 bool result;
42908 wxGBPosition temp2 ;
42909 PyObject * obj0 = 0 ;
42910 PyObject * obj1 = 0 ;
42911 char *kwnames[] = {
42912 (char *) "self",(char *) "other", NULL
42913 };
42914
42915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
42916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42917 if (SWIG_arg_fail(1)) SWIG_fail;
42918 {
42919 arg2 = &temp2;
42920 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42921 }
42922 {
42923 PyThreadState* __tstate = wxPyBeginAllowThreads();
42924 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42925
42926 wxPyEndAllowThreads(__tstate);
42927 if (PyErr_Occurred()) SWIG_fail;
42928 }
42929 {
42930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42931 }
42932 return resultobj;
42933 fail:
42934 return NULL;
42935 }
42936
42937
42938 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42939 PyObject *resultobj = NULL;
42940 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42941 int arg2 = (int) 0 ;
42942 int arg3 = (int) 0 ;
42943 PyObject * obj0 = 0 ;
42944 PyObject * obj1 = 0 ;
42945 PyObject * obj2 = 0 ;
42946 char *kwnames[] = {
42947 (char *) "self",(char *) "row",(char *) "col", NULL
42948 };
42949
42950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42952 if (SWIG_arg_fail(1)) SWIG_fail;
42953 if (obj1) {
42954 {
42955 arg2 = static_cast<int >(SWIG_As_int(obj1));
42956 if (SWIG_arg_fail(2)) SWIG_fail;
42957 }
42958 }
42959 if (obj2) {
42960 {
42961 arg3 = static_cast<int >(SWIG_As_int(obj2));
42962 if (SWIG_arg_fail(3)) SWIG_fail;
42963 }
42964 }
42965 {
42966 PyThreadState* __tstate = wxPyBeginAllowThreads();
42967 wxGBPosition_Set(arg1,arg2,arg3);
42968
42969 wxPyEndAllowThreads(__tstate);
42970 if (PyErr_Occurred()) SWIG_fail;
42971 }
42972 Py_INCREF(Py_None); resultobj = Py_None;
42973 return resultobj;
42974 fail:
42975 return NULL;
42976 }
42977
42978
42979 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42980 PyObject *resultobj = NULL;
42981 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42982 PyObject *result;
42983 PyObject * obj0 = 0 ;
42984 char *kwnames[] = {
42985 (char *) "self", NULL
42986 };
42987
42988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42990 if (SWIG_arg_fail(1)) SWIG_fail;
42991 {
42992 PyThreadState* __tstate = wxPyBeginAllowThreads();
42993 result = (PyObject *)wxGBPosition_Get(arg1);
42994
42995 wxPyEndAllowThreads(__tstate);
42996 if (PyErr_Occurred()) SWIG_fail;
42997 }
42998 resultobj = result;
42999 return resultobj;
43000 fail:
43001 return NULL;
43002 }
43003
43004
43005 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
43006 PyObject *obj;
43007 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43008 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
43009 Py_INCREF(obj);
43010 return Py_BuildValue((char *)"");
43011 }
43012 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43013 PyObject *resultobj = NULL;
43014 int arg1 = (int) 1 ;
43015 int arg2 = (int) 1 ;
43016 wxGBSpan *result;
43017 PyObject * obj0 = 0 ;
43018 PyObject * obj1 = 0 ;
43019 char *kwnames[] = {
43020 (char *) "rowspan",(char *) "colspan", NULL
43021 };
43022
43023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
43024 if (obj0) {
43025 {
43026 arg1 = static_cast<int >(SWIG_As_int(obj0));
43027 if (SWIG_arg_fail(1)) SWIG_fail;
43028 }
43029 }
43030 if (obj1) {
43031 {
43032 arg2 = static_cast<int >(SWIG_As_int(obj1));
43033 if (SWIG_arg_fail(2)) SWIG_fail;
43034 }
43035 }
43036 {
43037 PyThreadState* __tstate = wxPyBeginAllowThreads();
43038 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
43039
43040 wxPyEndAllowThreads(__tstate);
43041 if (PyErr_Occurred()) SWIG_fail;
43042 }
43043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
43044 return resultobj;
43045 fail:
43046 return NULL;
43047 }
43048
43049
43050 static PyObject *_wrap_delete_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43051 PyObject *resultobj = NULL;
43052 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43053 PyObject * obj0 = 0 ;
43054 char *kwnames[] = {
43055 (char *) "self", NULL
43056 };
43057
43058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GBSpan",kwnames,&obj0)) goto fail;
43059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43060 if (SWIG_arg_fail(1)) SWIG_fail;
43061 {
43062 PyThreadState* __tstate = wxPyBeginAllowThreads();
43063 delete arg1;
43064
43065 wxPyEndAllowThreads(__tstate);
43066 if (PyErr_Occurred()) SWIG_fail;
43067 }
43068 Py_INCREF(Py_None); resultobj = Py_None;
43069 return resultobj;
43070 fail:
43071 return NULL;
43072 }
43073
43074
43075 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
43076 PyObject *resultobj = NULL;
43077 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43078 int result;
43079 PyObject * obj0 = 0 ;
43080 char *kwnames[] = {
43081 (char *) "self", NULL
43082 };
43083
43084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
43085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43086 if (SWIG_arg_fail(1)) SWIG_fail;
43087 {
43088 PyThreadState* __tstate = wxPyBeginAllowThreads();
43089 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
43090
43091 wxPyEndAllowThreads(__tstate);
43092 if (PyErr_Occurred()) SWIG_fail;
43093 }
43094 {
43095 resultobj = SWIG_From_int(static_cast<int >(result));
43096 }
43097 return resultobj;
43098 fail:
43099 return NULL;
43100 }
43101
43102
43103 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
43104 PyObject *resultobj = NULL;
43105 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43106 int result;
43107 PyObject * obj0 = 0 ;
43108 char *kwnames[] = {
43109 (char *) "self", NULL
43110 };
43111
43112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
43113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43114 if (SWIG_arg_fail(1)) SWIG_fail;
43115 {
43116 PyThreadState* __tstate = wxPyBeginAllowThreads();
43117 result = (int)((wxGBSpan const *)arg1)->GetColspan();
43118
43119 wxPyEndAllowThreads(__tstate);
43120 if (PyErr_Occurred()) SWIG_fail;
43121 }
43122 {
43123 resultobj = SWIG_From_int(static_cast<int >(result));
43124 }
43125 return resultobj;
43126 fail:
43127 return NULL;
43128 }
43129
43130
43131 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
43132 PyObject *resultobj = NULL;
43133 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43134 int arg2 ;
43135 PyObject * obj0 = 0 ;
43136 PyObject * obj1 = 0 ;
43137 char *kwnames[] = {
43138 (char *) "self",(char *) "rowspan", NULL
43139 };
43140
43141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
43142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43143 if (SWIG_arg_fail(1)) SWIG_fail;
43144 {
43145 arg2 = static_cast<int >(SWIG_As_int(obj1));
43146 if (SWIG_arg_fail(2)) SWIG_fail;
43147 }
43148 {
43149 PyThreadState* __tstate = wxPyBeginAllowThreads();
43150 (arg1)->SetRowspan(arg2);
43151
43152 wxPyEndAllowThreads(__tstate);
43153 if (PyErr_Occurred()) SWIG_fail;
43154 }
43155 Py_INCREF(Py_None); resultobj = Py_None;
43156 return resultobj;
43157 fail:
43158 return NULL;
43159 }
43160
43161
43162 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
43163 PyObject *resultobj = NULL;
43164 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43165 int arg2 ;
43166 PyObject * obj0 = 0 ;
43167 PyObject * obj1 = 0 ;
43168 char *kwnames[] = {
43169 (char *) "self",(char *) "colspan", NULL
43170 };
43171
43172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
43173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43174 if (SWIG_arg_fail(1)) SWIG_fail;
43175 {
43176 arg2 = static_cast<int >(SWIG_As_int(obj1));
43177 if (SWIG_arg_fail(2)) SWIG_fail;
43178 }
43179 {
43180 PyThreadState* __tstate = wxPyBeginAllowThreads();
43181 (arg1)->SetColspan(arg2);
43182
43183 wxPyEndAllowThreads(__tstate);
43184 if (PyErr_Occurred()) SWIG_fail;
43185 }
43186 Py_INCREF(Py_None); resultobj = Py_None;
43187 return resultobj;
43188 fail:
43189 return NULL;
43190 }
43191
43192
43193 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
43194 PyObject *resultobj = NULL;
43195 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43196 wxGBSpan *arg2 = 0 ;
43197 bool result;
43198 wxGBSpan temp2 ;
43199 PyObject * obj0 = 0 ;
43200 PyObject * obj1 = 0 ;
43201 char *kwnames[] = {
43202 (char *) "self",(char *) "other", NULL
43203 };
43204
43205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
43206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43207 if (SWIG_arg_fail(1)) SWIG_fail;
43208 {
43209 arg2 = &temp2;
43210 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43211 }
43212 {
43213 PyThreadState* __tstate = wxPyBeginAllowThreads();
43214 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
43215
43216 wxPyEndAllowThreads(__tstate);
43217 if (PyErr_Occurred()) SWIG_fail;
43218 }
43219 {
43220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43221 }
43222 return resultobj;
43223 fail:
43224 return NULL;
43225 }
43226
43227
43228 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
43229 PyObject *resultobj = NULL;
43230 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43231 wxGBSpan *arg2 = 0 ;
43232 bool result;
43233 wxGBSpan temp2 ;
43234 PyObject * obj0 = 0 ;
43235 PyObject * obj1 = 0 ;
43236 char *kwnames[] = {
43237 (char *) "self",(char *) "other", NULL
43238 };
43239
43240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
43241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43242 if (SWIG_arg_fail(1)) SWIG_fail;
43243 {
43244 arg2 = &temp2;
43245 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43246 }
43247 {
43248 PyThreadState* __tstate = wxPyBeginAllowThreads();
43249 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
43250
43251 wxPyEndAllowThreads(__tstate);
43252 if (PyErr_Occurred()) SWIG_fail;
43253 }
43254 {
43255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43256 }
43257 return resultobj;
43258 fail:
43259 return NULL;
43260 }
43261
43262
43263 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43264 PyObject *resultobj = NULL;
43265 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43266 int arg2 = (int) 1 ;
43267 int arg3 = (int) 1 ;
43268 PyObject * obj0 = 0 ;
43269 PyObject * obj1 = 0 ;
43270 PyObject * obj2 = 0 ;
43271 char *kwnames[] = {
43272 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
43273 };
43274
43275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
43276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43277 if (SWIG_arg_fail(1)) SWIG_fail;
43278 if (obj1) {
43279 {
43280 arg2 = static_cast<int >(SWIG_As_int(obj1));
43281 if (SWIG_arg_fail(2)) SWIG_fail;
43282 }
43283 }
43284 if (obj2) {
43285 {
43286 arg3 = static_cast<int >(SWIG_As_int(obj2));
43287 if (SWIG_arg_fail(3)) SWIG_fail;
43288 }
43289 }
43290 {
43291 PyThreadState* __tstate = wxPyBeginAllowThreads();
43292 wxGBSpan_Set(arg1,arg2,arg3);
43293
43294 wxPyEndAllowThreads(__tstate);
43295 if (PyErr_Occurred()) SWIG_fail;
43296 }
43297 Py_INCREF(Py_None); resultobj = Py_None;
43298 return resultobj;
43299 fail:
43300 return NULL;
43301 }
43302
43303
43304 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
43305 PyObject *resultobj = NULL;
43306 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43307 PyObject *result;
43308 PyObject * obj0 = 0 ;
43309 char *kwnames[] = {
43310 (char *) "self", NULL
43311 };
43312
43313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
43314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43315 if (SWIG_arg_fail(1)) SWIG_fail;
43316 {
43317 PyThreadState* __tstate = wxPyBeginAllowThreads();
43318 result = (PyObject *)wxGBSpan_Get(arg1);
43319
43320 wxPyEndAllowThreads(__tstate);
43321 if (PyErr_Occurred()) SWIG_fail;
43322 }
43323 resultobj = result;
43324 return resultobj;
43325 fail:
43326 return NULL;
43327 }
43328
43329
43330 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
43331 PyObject *obj;
43332 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43333 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
43334 Py_INCREF(obj);
43335 return Py_BuildValue((char *)"");
43336 }
43337 static int _wrap_DefaultSpan_set(PyObject *) {
43338 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
43339 return 1;
43340 }
43341
43342
43343 static PyObject *_wrap_DefaultSpan_get(void) {
43344 PyObject *pyobj = NULL;
43345
43346 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
43347 return pyobj;
43348 }
43349
43350
43351 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
43352 PyObject *resultobj = NULL;
43353 wxGBSizerItem *result;
43354 char *kwnames[] = {
43355 NULL
43356 };
43357
43358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
43359 {
43360 PyThreadState* __tstate = wxPyBeginAllowThreads();
43361 result = (wxGBSizerItem *)new wxGBSizerItem();
43362
43363 wxPyEndAllowThreads(__tstate);
43364 if (PyErr_Occurred()) SWIG_fail;
43365 }
43366 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43367 return resultobj;
43368 fail:
43369 return NULL;
43370 }
43371
43372
43373 static PyObject *_wrap_delete_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
43374 PyObject *resultobj = NULL;
43375 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43376 PyObject * obj0 = 0 ;
43377 char *kwnames[] = {
43378 (char *) "self", NULL
43379 };
43380
43381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GBSizerItem",kwnames,&obj0)) goto fail;
43382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43383 if (SWIG_arg_fail(1)) SWIG_fail;
43384 {
43385 PyThreadState* __tstate = wxPyBeginAllowThreads();
43386 delete arg1;
43387
43388 wxPyEndAllowThreads(__tstate);
43389 if (PyErr_Occurred()) SWIG_fail;
43390 }
43391 Py_INCREF(Py_None); resultobj = Py_None;
43392 return resultobj;
43393 fail:
43394 return NULL;
43395 }
43396
43397
43398 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43399 PyObject *resultobj = NULL;
43400 wxWindow *arg1 = (wxWindow *) 0 ;
43401 wxGBPosition *arg2 = 0 ;
43402 wxGBSpan *arg3 = 0 ;
43403 int arg4 ;
43404 int arg5 ;
43405 PyObject *arg6 = (PyObject *) NULL ;
43406 wxGBSizerItem *result;
43407 wxGBPosition temp2 ;
43408 wxGBSpan temp3 ;
43409 PyObject * obj0 = 0 ;
43410 PyObject * obj1 = 0 ;
43411 PyObject * obj2 = 0 ;
43412 PyObject * obj3 = 0 ;
43413 PyObject * obj4 = 0 ;
43414 PyObject * obj5 = 0 ;
43415 char *kwnames[] = {
43416 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43417 };
43418
43419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43421 if (SWIG_arg_fail(1)) SWIG_fail;
43422 {
43423 arg2 = &temp2;
43424 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43425 }
43426 {
43427 arg3 = &temp3;
43428 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43429 }
43430 {
43431 arg4 = static_cast<int >(SWIG_As_int(obj3));
43432 if (SWIG_arg_fail(4)) SWIG_fail;
43433 }
43434 {
43435 arg5 = static_cast<int >(SWIG_As_int(obj4));
43436 if (SWIG_arg_fail(5)) SWIG_fail;
43437 }
43438 if (obj5) {
43439 arg6 = obj5;
43440 }
43441 {
43442 PyThreadState* __tstate = wxPyBeginAllowThreads();
43443 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43444
43445 wxPyEndAllowThreads(__tstate);
43446 if (PyErr_Occurred()) SWIG_fail;
43447 }
43448 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43449 return resultobj;
43450 fail:
43451 return NULL;
43452 }
43453
43454
43455 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43456 PyObject *resultobj = NULL;
43457 wxSizer *arg1 = (wxSizer *) 0 ;
43458 wxGBPosition *arg2 = 0 ;
43459 wxGBSpan *arg3 = 0 ;
43460 int arg4 ;
43461 int arg5 ;
43462 PyObject *arg6 = (PyObject *) NULL ;
43463 wxGBSizerItem *result;
43464 wxGBPosition temp2 ;
43465 wxGBSpan temp3 ;
43466 PyObject * obj0 = 0 ;
43467 PyObject * obj1 = 0 ;
43468 PyObject * obj2 = 0 ;
43469 PyObject * obj3 = 0 ;
43470 PyObject * obj4 = 0 ;
43471 PyObject * obj5 = 0 ;
43472 char *kwnames[] = {
43473 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43474 };
43475
43476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
43478 if (SWIG_arg_fail(1)) SWIG_fail;
43479 {
43480 arg2 = &temp2;
43481 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43482 }
43483 {
43484 arg3 = &temp3;
43485 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43486 }
43487 {
43488 arg4 = static_cast<int >(SWIG_As_int(obj3));
43489 if (SWIG_arg_fail(4)) SWIG_fail;
43490 }
43491 {
43492 arg5 = static_cast<int >(SWIG_As_int(obj4));
43493 if (SWIG_arg_fail(5)) SWIG_fail;
43494 }
43495 if (obj5) {
43496 arg6 = obj5;
43497 }
43498 {
43499 PyThreadState* __tstate = wxPyBeginAllowThreads();
43500 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43501
43502 wxPyEndAllowThreads(__tstate);
43503 if (PyErr_Occurred()) SWIG_fail;
43504 }
43505 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43506 return resultobj;
43507 fail:
43508 return NULL;
43509 }
43510
43511
43512 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
43513 PyObject *resultobj = NULL;
43514 int arg1 ;
43515 int arg2 ;
43516 wxGBPosition *arg3 = 0 ;
43517 wxGBSpan *arg4 = 0 ;
43518 int arg5 ;
43519 int arg6 ;
43520 PyObject *arg7 = (PyObject *) NULL ;
43521 wxGBSizerItem *result;
43522 wxGBPosition temp3 ;
43523 wxGBSpan temp4 ;
43524 PyObject * obj0 = 0 ;
43525 PyObject * obj1 = 0 ;
43526 PyObject * obj2 = 0 ;
43527 PyObject * obj3 = 0 ;
43528 PyObject * obj4 = 0 ;
43529 PyObject * obj5 = 0 ;
43530 PyObject * obj6 = 0 ;
43531 char *kwnames[] = {
43532 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43533 };
43534
43535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43536 {
43537 arg1 = static_cast<int >(SWIG_As_int(obj0));
43538 if (SWIG_arg_fail(1)) SWIG_fail;
43539 }
43540 {
43541 arg2 = static_cast<int >(SWIG_As_int(obj1));
43542 if (SWIG_arg_fail(2)) SWIG_fail;
43543 }
43544 {
43545 arg3 = &temp3;
43546 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43547 }
43548 {
43549 arg4 = &temp4;
43550 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43551 }
43552 {
43553 arg5 = static_cast<int >(SWIG_As_int(obj4));
43554 if (SWIG_arg_fail(5)) SWIG_fail;
43555 }
43556 {
43557 arg6 = static_cast<int >(SWIG_As_int(obj5));
43558 if (SWIG_arg_fail(6)) SWIG_fail;
43559 }
43560 if (obj6) {
43561 arg7 = obj6;
43562 }
43563 {
43564 PyThreadState* __tstate = wxPyBeginAllowThreads();
43565 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43566
43567 wxPyEndAllowThreads(__tstate);
43568 if (PyErr_Occurred()) SWIG_fail;
43569 }
43570 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43571 return resultobj;
43572 fail:
43573 return NULL;
43574 }
43575
43576
43577 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43578 PyObject *resultobj = NULL;
43579 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43580 wxGBPosition result;
43581 PyObject * obj0 = 0 ;
43582 char *kwnames[] = {
43583 (char *) "self", NULL
43584 };
43585
43586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
43587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43588 if (SWIG_arg_fail(1)) SWIG_fail;
43589 {
43590 PyThreadState* __tstate = wxPyBeginAllowThreads();
43591 result = ((wxGBSizerItem const *)arg1)->GetPos();
43592
43593 wxPyEndAllowThreads(__tstate);
43594 if (PyErr_Occurred()) SWIG_fail;
43595 }
43596 {
43597 wxGBPosition * resultptr;
43598 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
43599 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43600 }
43601 return resultobj;
43602 fail:
43603 return NULL;
43604 }
43605
43606
43607 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43608 PyObject *resultobj = NULL;
43609 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43610 wxGBSpan result;
43611 PyObject * obj0 = 0 ;
43612 char *kwnames[] = {
43613 (char *) "self", NULL
43614 };
43615
43616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
43617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43618 if (SWIG_arg_fail(1)) SWIG_fail;
43619 {
43620 PyThreadState* __tstate = wxPyBeginAllowThreads();
43621 result = ((wxGBSizerItem const *)arg1)->GetSpan();
43622
43623 wxPyEndAllowThreads(__tstate);
43624 if (PyErr_Occurred()) SWIG_fail;
43625 }
43626 {
43627 wxGBSpan * resultptr;
43628 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
43629 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43630 }
43631 return resultobj;
43632 fail:
43633 return NULL;
43634 }
43635
43636
43637 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43638 PyObject *resultobj = NULL;
43639 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43640 wxGBPosition *arg2 = 0 ;
43641 bool result;
43642 wxGBPosition temp2 ;
43643 PyObject * obj0 = 0 ;
43644 PyObject * obj1 = 0 ;
43645 char *kwnames[] = {
43646 (char *) "self",(char *) "pos", NULL
43647 };
43648
43649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
43650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43651 if (SWIG_arg_fail(1)) SWIG_fail;
43652 {
43653 arg2 = &temp2;
43654 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43655 }
43656 {
43657 PyThreadState* __tstate = wxPyBeginAllowThreads();
43658 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
43659
43660 wxPyEndAllowThreads(__tstate);
43661 if (PyErr_Occurred()) SWIG_fail;
43662 }
43663 {
43664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43665 }
43666 return resultobj;
43667 fail:
43668 return NULL;
43669 }
43670
43671
43672 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43673 PyObject *resultobj = NULL;
43674 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43675 wxGBSpan *arg2 = 0 ;
43676 bool result;
43677 wxGBSpan temp2 ;
43678 PyObject * obj0 = 0 ;
43679 PyObject * obj1 = 0 ;
43680 char *kwnames[] = {
43681 (char *) "self",(char *) "span", NULL
43682 };
43683
43684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
43685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43686 if (SWIG_arg_fail(1)) SWIG_fail;
43687 {
43688 arg2 = &temp2;
43689 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43690 }
43691 {
43692 PyThreadState* __tstate = wxPyBeginAllowThreads();
43693 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
43694
43695 wxPyEndAllowThreads(__tstate);
43696 if (PyErr_Occurred()) SWIG_fail;
43697 }
43698 {
43699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43700 }
43701 return resultobj;
43702 fail:
43703 return NULL;
43704 }
43705
43706
43707 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
43708 PyObject *resultobj = NULL;
43709 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43710 wxGBSizerItem *arg2 = 0 ;
43711 bool result;
43712 PyObject * obj0 = 0 ;
43713 PyObject * obj1 = 0 ;
43714 char *kwnames[] = {
43715 (char *) "self",(char *) "other", NULL
43716 };
43717
43718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
43719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43720 if (SWIG_arg_fail(1)) SWIG_fail;
43721 {
43722 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43723 if (SWIG_arg_fail(2)) SWIG_fail;
43724 if (arg2 == NULL) {
43725 SWIG_null_ref("wxGBSizerItem");
43726 }
43727 if (SWIG_arg_fail(2)) SWIG_fail;
43728 }
43729 {
43730 PyThreadState* __tstate = wxPyBeginAllowThreads();
43731 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
43732
43733 wxPyEndAllowThreads(__tstate);
43734 if (PyErr_Occurred()) SWIG_fail;
43735 }
43736 {
43737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43738 }
43739 return resultobj;
43740 fail:
43741 return NULL;
43742 }
43743
43744
43745 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
43746 PyObject *resultobj = NULL;
43747 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43748 wxGBPosition *arg2 = 0 ;
43749 wxGBSpan *arg3 = 0 ;
43750 bool result;
43751 wxGBPosition temp2 ;
43752 wxGBSpan temp3 ;
43753 PyObject * obj0 = 0 ;
43754 PyObject * obj1 = 0 ;
43755 PyObject * obj2 = 0 ;
43756 char *kwnames[] = {
43757 (char *) "self",(char *) "pos",(char *) "span", NULL
43758 };
43759
43760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
43761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43762 if (SWIG_arg_fail(1)) SWIG_fail;
43763 {
43764 arg2 = &temp2;
43765 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43766 }
43767 {
43768 arg3 = &temp3;
43769 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43770 }
43771 {
43772 PyThreadState* __tstate = wxPyBeginAllowThreads();
43773 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
43774
43775 wxPyEndAllowThreads(__tstate);
43776 if (PyErr_Occurred()) SWIG_fail;
43777 }
43778 {
43779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43780 }
43781 return resultobj;
43782 fail:
43783 return NULL;
43784 }
43785
43786
43787 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
43788 PyObject *resultobj = NULL;
43789 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43790 wxGBPosition result;
43791 PyObject * obj0 = 0 ;
43792 char *kwnames[] = {
43793 (char *) "self", NULL
43794 };
43795
43796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
43797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43798 if (SWIG_arg_fail(1)) SWIG_fail;
43799 {
43800 PyThreadState* __tstate = wxPyBeginAllowThreads();
43801 result = wxGBSizerItem_GetEndPos(arg1);
43802
43803 wxPyEndAllowThreads(__tstate);
43804 if (PyErr_Occurred()) SWIG_fail;
43805 }
43806 {
43807 wxGBPosition * resultptr;
43808 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
43809 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43810 }
43811 return resultobj;
43812 fail:
43813 return NULL;
43814 }
43815
43816
43817 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43818 PyObject *resultobj = NULL;
43819 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43820 wxGridBagSizer *result;
43821 PyObject * obj0 = 0 ;
43822 char *kwnames[] = {
43823 (char *) "self", NULL
43824 };
43825
43826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
43827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43828 if (SWIG_arg_fail(1)) SWIG_fail;
43829 {
43830 PyThreadState* __tstate = wxPyBeginAllowThreads();
43831 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
43832
43833 wxPyEndAllowThreads(__tstate);
43834 if (PyErr_Occurred()) SWIG_fail;
43835 }
43836 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
43837 return resultobj;
43838 fail:
43839 return NULL;
43840 }
43841
43842
43843 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43844 PyObject *resultobj = NULL;
43845 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43846 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
43847 PyObject * obj0 = 0 ;
43848 PyObject * obj1 = 0 ;
43849 char *kwnames[] = {
43850 (char *) "self",(char *) "sizer", NULL
43851 };
43852
43853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
43854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43855 if (SWIG_arg_fail(1)) SWIG_fail;
43856 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43857 if (SWIG_arg_fail(2)) SWIG_fail;
43858 {
43859 PyThreadState* __tstate = wxPyBeginAllowThreads();
43860 (arg1)->SetGBSizer(arg2);
43861
43862 wxPyEndAllowThreads(__tstate);
43863 if (PyErr_Occurred()) SWIG_fail;
43864 }
43865 Py_INCREF(Py_None); resultobj = Py_None;
43866 return resultobj;
43867 fail:
43868 return NULL;
43869 }
43870
43871
43872 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
43873 PyObject *obj;
43874 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43875 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
43876 Py_INCREF(obj);
43877 return Py_BuildValue((char *)"");
43878 }
43879 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43880 PyObject *resultobj = NULL;
43881 int arg1 = (int) 0 ;
43882 int arg2 = (int) 0 ;
43883 wxGridBagSizer *result;
43884 PyObject * obj0 = 0 ;
43885 PyObject * obj1 = 0 ;
43886 char *kwnames[] = {
43887 (char *) "vgap",(char *) "hgap", NULL
43888 };
43889
43890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
43891 if (obj0) {
43892 {
43893 arg1 = static_cast<int >(SWIG_As_int(obj0));
43894 if (SWIG_arg_fail(1)) SWIG_fail;
43895 }
43896 }
43897 if (obj1) {
43898 {
43899 arg2 = static_cast<int >(SWIG_As_int(obj1));
43900 if (SWIG_arg_fail(2)) SWIG_fail;
43901 }
43902 }
43903 {
43904 PyThreadState* __tstate = wxPyBeginAllowThreads();
43905 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
43906
43907 wxPyEndAllowThreads(__tstate);
43908 if (PyErr_Occurred()) SWIG_fail;
43909 }
43910 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
43911 return resultobj;
43912 fail:
43913 return NULL;
43914 }
43915
43916
43917 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
43918 PyObject *resultobj = NULL;
43919 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43920 PyObject *arg2 = (PyObject *) 0 ;
43921 wxGBPosition *arg3 = 0 ;
43922 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
43923 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
43924 int arg5 = (int) 0 ;
43925 int arg6 = (int) 0 ;
43926 PyObject *arg7 = (PyObject *) NULL ;
43927 wxGBSizerItem *result;
43928 wxGBPosition temp3 ;
43929 wxGBSpan temp4 ;
43930 PyObject * obj0 = 0 ;
43931 PyObject * obj1 = 0 ;
43932 PyObject * obj2 = 0 ;
43933 PyObject * obj3 = 0 ;
43934 PyObject * obj4 = 0 ;
43935 PyObject * obj5 = 0 ;
43936 PyObject * obj6 = 0 ;
43937 char *kwnames[] = {
43938 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43939 };
43940
43941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43943 if (SWIG_arg_fail(1)) SWIG_fail;
43944 arg2 = obj1;
43945 {
43946 arg3 = &temp3;
43947 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43948 }
43949 if (obj3) {
43950 {
43951 arg4 = &temp4;
43952 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43953 }
43954 }
43955 if (obj4) {
43956 {
43957 arg5 = static_cast<int >(SWIG_As_int(obj4));
43958 if (SWIG_arg_fail(5)) SWIG_fail;
43959 }
43960 }
43961 if (obj5) {
43962 {
43963 arg6 = static_cast<int >(SWIG_As_int(obj5));
43964 if (SWIG_arg_fail(6)) SWIG_fail;
43965 }
43966 }
43967 if (obj6) {
43968 arg7 = obj6;
43969 }
43970 {
43971 PyThreadState* __tstate = wxPyBeginAllowThreads();
43972 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43973
43974 wxPyEndAllowThreads(__tstate);
43975 if (PyErr_Occurred()) SWIG_fail;
43976 }
43977 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43978 return resultobj;
43979 fail:
43980 return NULL;
43981 }
43982
43983
43984 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
43985 PyObject *resultobj = NULL;
43986 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43987 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43988 wxGBSizerItem *result;
43989 PyObject * obj0 = 0 ;
43990 PyObject * obj1 = 0 ;
43991 char *kwnames[] = {
43992 (char *) "self",(char *) "item", NULL
43993 };
43994
43995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
43996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43997 if (SWIG_arg_fail(1)) SWIG_fail;
43998 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
43999 if (SWIG_arg_fail(2)) SWIG_fail;
44000 {
44001 PyThreadState* __tstate = wxPyBeginAllowThreads();
44002 result = (wxGBSizerItem *)(arg1)->Add(arg2);
44003
44004 wxPyEndAllowThreads(__tstate);
44005 if (PyErr_Occurred()) SWIG_fail;
44006 }
44007 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44008 return resultobj;
44009 fail:
44010 return NULL;
44011 }
44012
44013
44014 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
44015 PyObject *resultobj = NULL;
44016 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44017 int arg2 ;
44018 int arg3 ;
44019 wxSize result;
44020 PyObject * obj0 = 0 ;
44021 PyObject * obj1 = 0 ;
44022 PyObject * obj2 = 0 ;
44023 char *kwnames[] = {
44024 (char *) "self",(char *) "row",(char *) "col", NULL
44025 };
44026
44027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
44028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44029 if (SWIG_arg_fail(1)) SWIG_fail;
44030 {
44031 arg2 = static_cast<int >(SWIG_As_int(obj1));
44032 if (SWIG_arg_fail(2)) SWIG_fail;
44033 }
44034 {
44035 arg3 = static_cast<int >(SWIG_As_int(obj2));
44036 if (SWIG_arg_fail(3)) SWIG_fail;
44037 }
44038 {
44039 PyThreadState* __tstate = wxPyBeginAllowThreads();
44040 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
44041
44042 wxPyEndAllowThreads(__tstate);
44043 if (PyErr_Occurred()) SWIG_fail;
44044 }
44045 {
44046 wxSize * resultptr;
44047 resultptr = new wxSize(static_cast<wxSize & >(result));
44048 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
44049 }
44050 return resultobj;
44051 fail:
44052 return NULL;
44053 }
44054
44055
44056 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
44057 PyObject *resultobj = NULL;
44058 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44059 wxSize result;
44060 PyObject * obj0 = 0 ;
44061 char *kwnames[] = {
44062 (char *) "self", NULL
44063 };
44064
44065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
44066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44067 if (SWIG_arg_fail(1)) SWIG_fail;
44068 {
44069 PyThreadState* __tstate = wxPyBeginAllowThreads();
44070 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
44071
44072 wxPyEndAllowThreads(__tstate);
44073 if (PyErr_Occurred()) SWIG_fail;
44074 }
44075 {
44076 wxSize * resultptr;
44077 resultptr = new wxSize(static_cast<wxSize & >(result));
44078 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
44079 }
44080 return resultobj;
44081 fail:
44082 return NULL;
44083 }
44084
44085
44086 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
44087 PyObject *resultobj = NULL;
44088 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44089 wxSize *arg2 = 0 ;
44090 wxSize temp2 ;
44091 PyObject * obj0 = 0 ;
44092 PyObject * obj1 = 0 ;
44093 char *kwnames[] = {
44094 (char *) "self",(char *) "sz", NULL
44095 };
44096
44097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
44098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44099 if (SWIG_arg_fail(1)) SWIG_fail;
44100 {
44101 arg2 = &temp2;
44102 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
44103 }
44104 {
44105 PyThreadState* __tstate = wxPyBeginAllowThreads();
44106 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
44107
44108 wxPyEndAllowThreads(__tstate);
44109 if (PyErr_Occurred()) SWIG_fail;
44110 }
44111 Py_INCREF(Py_None); resultobj = Py_None;
44112 return resultobj;
44113 fail:
44114 return NULL;
44115 }
44116
44117
44118 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
44119 PyObject *resultobj = NULL;
44120 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44121 wxWindow *arg2 = (wxWindow *) 0 ;
44122 wxGBPosition result;
44123 PyObject * obj0 = 0 ;
44124 PyObject * obj1 = 0 ;
44125
44126 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44128 if (SWIG_arg_fail(1)) SWIG_fail;
44129 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44130 if (SWIG_arg_fail(2)) SWIG_fail;
44131 {
44132 PyThreadState* __tstate = wxPyBeginAllowThreads();
44133 result = (arg1)->GetItemPosition(arg2);
44134
44135 wxPyEndAllowThreads(__tstate);
44136 if (PyErr_Occurred()) SWIG_fail;
44137 }
44138 {
44139 wxGBPosition * resultptr;
44140 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44141 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44142 }
44143 return resultobj;
44144 fail:
44145 return NULL;
44146 }
44147
44148
44149 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
44150 PyObject *resultobj = NULL;
44151 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44152 wxSizer *arg2 = (wxSizer *) 0 ;
44153 wxGBPosition result;
44154 PyObject * obj0 = 0 ;
44155 PyObject * obj1 = 0 ;
44156
44157 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44159 if (SWIG_arg_fail(1)) SWIG_fail;
44160 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44161 if (SWIG_arg_fail(2)) SWIG_fail;
44162 {
44163 PyThreadState* __tstate = wxPyBeginAllowThreads();
44164 result = (arg1)->GetItemPosition(arg2);
44165
44166 wxPyEndAllowThreads(__tstate);
44167 if (PyErr_Occurred()) SWIG_fail;
44168 }
44169 {
44170 wxGBPosition * resultptr;
44171 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44172 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44173 }
44174 return resultobj;
44175 fail:
44176 return NULL;
44177 }
44178
44179
44180 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44181 PyObject *resultobj = NULL;
44182 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44183 size_t arg2 ;
44184 wxGBPosition result;
44185 PyObject * obj0 = 0 ;
44186 PyObject * obj1 = 0 ;
44187
44188 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44190 if (SWIG_arg_fail(1)) SWIG_fail;
44191 {
44192 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44193 if (SWIG_arg_fail(2)) SWIG_fail;
44194 }
44195 {
44196 PyThreadState* __tstate = wxPyBeginAllowThreads();
44197 result = (arg1)->GetItemPosition(arg2);
44198
44199 wxPyEndAllowThreads(__tstate);
44200 if (PyErr_Occurred()) SWIG_fail;
44201 }
44202 {
44203 wxGBPosition * resultptr;
44204 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44205 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44206 }
44207 return resultobj;
44208 fail:
44209 return NULL;
44210 }
44211
44212
44213 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
44214 int argc;
44215 PyObject *argv[3];
44216 int ii;
44217
44218 argc = PyObject_Length(args);
44219 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44220 argv[ii] = PyTuple_GetItem(args,ii);
44221 }
44222 if (argc == 2) {
44223 int _v;
44224 {
44225 void *ptr;
44226 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44227 _v = 0;
44228 PyErr_Clear();
44229 } else {
44230 _v = 1;
44231 }
44232 }
44233 if (_v) {
44234 {
44235 void *ptr;
44236 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44237 _v = 0;
44238 PyErr_Clear();
44239 } else {
44240 _v = 1;
44241 }
44242 }
44243 if (_v) {
44244 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
44245 }
44246 }
44247 }
44248 if (argc == 2) {
44249 int _v;
44250 {
44251 void *ptr;
44252 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44253 _v = 0;
44254 PyErr_Clear();
44255 } else {
44256 _v = 1;
44257 }
44258 }
44259 if (_v) {
44260 {
44261 void *ptr;
44262 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44263 _v = 0;
44264 PyErr_Clear();
44265 } else {
44266 _v = 1;
44267 }
44268 }
44269 if (_v) {
44270 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
44271 }
44272 }
44273 }
44274 if (argc == 2) {
44275 int _v;
44276 {
44277 void *ptr;
44278 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44279 _v = 0;
44280 PyErr_Clear();
44281 } else {
44282 _v = 1;
44283 }
44284 }
44285 if (_v) {
44286 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44287 if (_v) {
44288 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
44289 }
44290 }
44291 }
44292
44293 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
44294 return NULL;
44295 }
44296
44297
44298 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
44299 PyObject *resultobj = NULL;
44300 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44301 wxWindow *arg2 = (wxWindow *) 0 ;
44302 wxGBPosition *arg3 = 0 ;
44303 bool result;
44304 wxGBPosition temp3 ;
44305 PyObject * obj0 = 0 ;
44306 PyObject * obj1 = 0 ;
44307 PyObject * obj2 = 0 ;
44308
44309 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44311 if (SWIG_arg_fail(1)) SWIG_fail;
44312 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44313 if (SWIG_arg_fail(2)) SWIG_fail;
44314 {
44315 arg3 = &temp3;
44316 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44317 }
44318 {
44319 PyThreadState* __tstate = wxPyBeginAllowThreads();
44320 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44321
44322 wxPyEndAllowThreads(__tstate);
44323 if (PyErr_Occurred()) SWIG_fail;
44324 }
44325 {
44326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44327 }
44328 return resultobj;
44329 fail:
44330 return NULL;
44331 }
44332
44333
44334 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
44335 PyObject *resultobj = NULL;
44336 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44337 wxSizer *arg2 = (wxSizer *) 0 ;
44338 wxGBPosition *arg3 = 0 ;
44339 bool result;
44340 wxGBPosition temp3 ;
44341 PyObject * obj0 = 0 ;
44342 PyObject * obj1 = 0 ;
44343 PyObject * obj2 = 0 ;
44344
44345 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44347 if (SWIG_arg_fail(1)) SWIG_fail;
44348 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44349 if (SWIG_arg_fail(2)) SWIG_fail;
44350 {
44351 arg3 = &temp3;
44352 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44353 }
44354 {
44355 PyThreadState* __tstate = wxPyBeginAllowThreads();
44356 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44357
44358 wxPyEndAllowThreads(__tstate);
44359 if (PyErr_Occurred()) SWIG_fail;
44360 }
44361 {
44362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44363 }
44364 return resultobj;
44365 fail:
44366 return NULL;
44367 }
44368
44369
44370 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44371 PyObject *resultobj = NULL;
44372 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44373 size_t arg2 ;
44374 wxGBPosition *arg3 = 0 ;
44375 bool result;
44376 wxGBPosition temp3 ;
44377 PyObject * obj0 = 0 ;
44378 PyObject * obj1 = 0 ;
44379 PyObject * obj2 = 0 ;
44380
44381 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44383 if (SWIG_arg_fail(1)) SWIG_fail;
44384 {
44385 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44386 if (SWIG_arg_fail(2)) SWIG_fail;
44387 }
44388 {
44389 arg3 = &temp3;
44390 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44391 }
44392 {
44393 PyThreadState* __tstate = wxPyBeginAllowThreads();
44394 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44395
44396 wxPyEndAllowThreads(__tstate);
44397 if (PyErr_Occurred()) SWIG_fail;
44398 }
44399 {
44400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44401 }
44402 return resultobj;
44403 fail:
44404 return NULL;
44405 }
44406
44407
44408 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
44409 int argc;
44410 PyObject *argv[4];
44411 int ii;
44412
44413 argc = PyObject_Length(args);
44414 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44415 argv[ii] = PyTuple_GetItem(args,ii);
44416 }
44417 if (argc == 3) {
44418 int _v;
44419 {
44420 void *ptr;
44421 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44422 _v = 0;
44423 PyErr_Clear();
44424 } else {
44425 _v = 1;
44426 }
44427 }
44428 if (_v) {
44429 {
44430 void *ptr;
44431 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44432 _v = 0;
44433 PyErr_Clear();
44434 } else {
44435 _v = 1;
44436 }
44437 }
44438 if (_v) {
44439 {
44440 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44441 }
44442 if (_v) {
44443 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
44444 }
44445 }
44446 }
44447 }
44448 if (argc == 3) {
44449 int _v;
44450 {
44451 void *ptr;
44452 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44453 _v = 0;
44454 PyErr_Clear();
44455 } else {
44456 _v = 1;
44457 }
44458 }
44459 if (_v) {
44460 {
44461 void *ptr;
44462 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44463 _v = 0;
44464 PyErr_Clear();
44465 } else {
44466 _v = 1;
44467 }
44468 }
44469 if (_v) {
44470 {
44471 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44472 }
44473 if (_v) {
44474 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
44475 }
44476 }
44477 }
44478 }
44479 if (argc == 3) {
44480 int _v;
44481 {
44482 void *ptr;
44483 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44484 _v = 0;
44485 PyErr_Clear();
44486 } else {
44487 _v = 1;
44488 }
44489 }
44490 if (_v) {
44491 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44492 if (_v) {
44493 {
44494 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44495 }
44496 if (_v) {
44497 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
44498 }
44499 }
44500 }
44501 }
44502
44503 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
44504 return NULL;
44505 }
44506
44507
44508 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44509 PyObject *resultobj = NULL;
44510 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44511 wxWindow *arg2 = (wxWindow *) 0 ;
44512 wxGBSpan result;
44513 PyObject * obj0 = 0 ;
44514 PyObject * obj1 = 0 ;
44515
44516 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44518 if (SWIG_arg_fail(1)) SWIG_fail;
44519 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44520 if (SWIG_arg_fail(2)) SWIG_fail;
44521 {
44522 PyThreadState* __tstate = wxPyBeginAllowThreads();
44523 result = (arg1)->GetItemSpan(arg2);
44524
44525 wxPyEndAllowThreads(__tstate);
44526 if (PyErr_Occurred()) SWIG_fail;
44527 }
44528 {
44529 wxGBSpan * resultptr;
44530 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44531 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44532 }
44533 return resultobj;
44534 fail:
44535 return NULL;
44536 }
44537
44538
44539 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44540 PyObject *resultobj = NULL;
44541 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44542 wxSizer *arg2 = (wxSizer *) 0 ;
44543 wxGBSpan result;
44544 PyObject * obj0 = 0 ;
44545 PyObject * obj1 = 0 ;
44546
44547 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44549 if (SWIG_arg_fail(1)) SWIG_fail;
44550 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44551 if (SWIG_arg_fail(2)) SWIG_fail;
44552 {
44553 PyThreadState* __tstate = wxPyBeginAllowThreads();
44554 result = (arg1)->GetItemSpan(arg2);
44555
44556 wxPyEndAllowThreads(__tstate);
44557 if (PyErr_Occurred()) SWIG_fail;
44558 }
44559 {
44560 wxGBSpan * resultptr;
44561 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44562 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44563 }
44564 return resultobj;
44565 fail:
44566 return NULL;
44567 }
44568
44569
44570 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44571 PyObject *resultobj = NULL;
44572 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44573 size_t arg2 ;
44574 wxGBSpan result;
44575 PyObject * obj0 = 0 ;
44576 PyObject * obj1 = 0 ;
44577
44578 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44580 if (SWIG_arg_fail(1)) SWIG_fail;
44581 {
44582 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44583 if (SWIG_arg_fail(2)) SWIG_fail;
44584 }
44585 {
44586 PyThreadState* __tstate = wxPyBeginAllowThreads();
44587 result = (arg1)->GetItemSpan(arg2);
44588
44589 wxPyEndAllowThreads(__tstate);
44590 if (PyErr_Occurred()) SWIG_fail;
44591 }
44592 {
44593 wxGBSpan * resultptr;
44594 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44595 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44596 }
44597 return resultobj;
44598 fail:
44599 return NULL;
44600 }
44601
44602
44603 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
44604 int argc;
44605 PyObject *argv[3];
44606 int ii;
44607
44608 argc = PyObject_Length(args);
44609 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44610 argv[ii] = PyTuple_GetItem(args,ii);
44611 }
44612 if (argc == 2) {
44613 int _v;
44614 {
44615 void *ptr;
44616 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44617 _v = 0;
44618 PyErr_Clear();
44619 } else {
44620 _v = 1;
44621 }
44622 }
44623 if (_v) {
44624 {
44625 void *ptr;
44626 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44627 _v = 0;
44628 PyErr_Clear();
44629 } else {
44630 _v = 1;
44631 }
44632 }
44633 if (_v) {
44634 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
44635 }
44636 }
44637 }
44638 if (argc == 2) {
44639 int _v;
44640 {
44641 void *ptr;
44642 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44643 _v = 0;
44644 PyErr_Clear();
44645 } else {
44646 _v = 1;
44647 }
44648 }
44649 if (_v) {
44650 {
44651 void *ptr;
44652 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44653 _v = 0;
44654 PyErr_Clear();
44655 } else {
44656 _v = 1;
44657 }
44658 }
44659 if (_v) {
44660 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
44661 }
44662 }
44663 }
44664 if (argc == 2) {
44665 int _v;
44666 {
44667 void *ptr;
44668 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44669 _v = 0;
44670 PyErr_Clear();
44671 } else {
44672 _v = 1;
44673 }
44674 }
44675 if (_v) {
44676 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44677 if (_v) {
44678 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
44679 }
44680 }
44681 }
44682
44683 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
44684 return NULL;
44685 }
44686
44687
44688 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44689 PyObject *resultobj = NULL;
44690 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44691 wxWindow *arg2 = (wxWindow *) 0 ;
44692 wxGBSpan *arg3 = 0 ;
44693 bool result;
44694 wxGBSpan temp3 ;
44695 PyObject * obj0 = 0 ;
44696 PyObject * obj1 = 0 ;
44697 PyObject * obj2 = 0 ;
44698
44699 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44701 if (SWIG_arg_fail(1)) SWIG_fail;
44702 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44703 if (SWIG_arg_fail(2)) SWIG_fail;
44704 {
44705 arg3 = &temp3;
44706 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44707 }
44708 {
44709 PyThreadState* __tstate = wxPyBeginAllowThreads();
44710 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44711
44712 wxPyEndAllowThreads(__tstate);
44713 if (PyErr_Occurred()) SWIG_fail;
44714 }
44715 {
44716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44717 }
44718 return resultobj;
44719 fail:
44720 return NULL;
44721 }
44722
44723
44724 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44725 PyObject *resultobj = NULL;
44726 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44727 wxSizer *arg2 = (wxSizer *) 0 ;
44728 wxGBSpan *arg3 = 0 ;
44729 bool result;
44730 wxGBSpan temp3 ;
44731 PyObject * obj0 = 0 ;
44732 PyObject * obj1 = 0 ;
44733 PyObject * obj2 = 0 ;
44734
44735 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44737 if (SWIG_arg_fail(1)) SWIG_fail;
44738 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44739 if (SWIG_arg_fail(2)) SWIG_fail;
44740 {
44741 arg3 = &temp3;
44742 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44743 }
44744 {
44745 PyThreadState* __tstate = wxPyBeginAllowThreads();
44746 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44747
44748 wxPyEndAllowThreads(__tstate);
44749 if (PyErr_Occurred()) SWIG_fail;
44750 }
44751 {
44752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44753 }
44754 return resultobj;
44755 fail:
44756 return NULL;
44757 }
44758
44759
44760 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44761 PyObject *resultobj = NULL;
44762 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44763 size_t arg2 ;
44764 wxGBSpan *arg3 = 0 ;
44765 bool result;
44766 wxGBSpan temp3 ;
44767 PyObject * obj0 = 0 ;
44768 PyObject * obj1 = 0 ;
44769 PyObject * obj2 = 0 ;
44770
44771 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44773 if (SWIG_arg_fail(1)) SWIG_fail;
44774 {
44775 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44776 if (SWIG_arg_fail(2)) SWIG_fail;
44777 }
44778 {
44779 arg3 = &temp3;
44780 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44781 }
44782 {
44783 PyThreadState* __tstate = wxPyBeginAllowThreads();
44784 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44785
44786 wxPyEndAllowThreads(__tstate);
44787 if (PyErr_Occurred()) SWIG_fail;
44788 }
44789 {
44790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44791 }
44792 return resultobj;
44793 fail:
44794 return NULL;
44795 }
44796
44797
44798 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
44799 int argc;
44800 PyObject *argv[4];
44801 int ii;
44802
44803 argc = PyObject_Length(args);
44804 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44805 argv[ii] = PyTuple_GetItem(args,ii);
44806 }
44807 if (argc == 3) {
44808 int _v;
44809 {
44810 void *ptr;
44811 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44812 _v = 0;
44813 PyErr_Clear();
44814 } else {
44815 _v = 1;
44816 }
44817 }
44818 if (_v) {
44819 {
44820 void *ptr;
44821 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44822 _v = 0;
44823 PyErr_Clear();
44824 } else {
44825 _v = 1;
44826 }
44827 }
44828 if (_v) {
44829 {
44830 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44831 }
44832 if (_v) {
44833 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
44834 }
44835 }
44836 }
44837 }
44838 if (argc == 3) {
44839 int _v;
44840 {
44841 void *ptr;
44842 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44843 _v = 0;
44844 PyErr_Clear();
44845 } else {
44846 _v = 1;
44847 }
44848 }
44849 if (_v) {
44850 {
44851 void *ptr;
44852 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44853 _v = 0;
44854 PyErr_Clear();
44855 } else {
44856 _v = 1;
44857 }
44858 }
44859 if (_v) {
44860 {
44861 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44862 }
44863 if (_v) {
44864 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
44865 }
44866 }
44867 }
44868 }
44869 if (argc == 3) {
44870 int _v;
44871 {
44872 void *ptr;
44873 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44874 _v = 0;
44875 PyErr_Clear();
44876 } else {
44877 _v = 1;
44878 }
44879 }
44880 if (_v) {
44881 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44882 if (_v) {
44883 {
44884 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44885 }
44886 if (_v) {
44887 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
44888 }
44889 }
44890 }
44891 }
44892
44893 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
44894 return NULL;
44895 }
44896
44897
44898 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
44899 PyObject *resultobj = NULL;
44900 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44901 wxWindow *arg2 = (wxWindow *) 0 ;
44902 wxGBSizerItem *result;
44903 PyObject * obj0 = 0 ;
44904 PyObject * obj1 = 0 ;
44905
44906 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44908 if (SWIG_arg_fail(1)) SWIG_fail;
44909 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44910 if (SWIG_arg_fail(2)) SWIG_fail;
44911 {
44912 PyThreadState* __tstate = wxPyBeginAllowThreads();
44913 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44914
44915 wxPyEndAllowThreads(__tstate);
44916 if (PyErr_Occurred()) SWIG_fail;
44917 }
44918 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44919 return resultobj;
44920 fail:
44921 return NULL;
44922 }
44923
44924
44925 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
44926 PyObject *resultobj = NULL;
44927 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44928 wxSizer *arg2 = (wxSizer *) 0 ;
44929 wxGBSizerItem *result;
44930 PyObject * obj0 = 0 ;
44931 PyObject * obj1 = 0 ;
44932
44933 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44935 if (SWIG_arg_fail(1)) SWIG_fail;
44936 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44937 if (SWIG_arg_fail(2)) SWIG_fail;
44938 {
44939 PyThreadState* __tstate = wxPyBeginAllowThreads();
44940 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44941
44942 wxPyEndAllowThreads(__tstate);
44943 if (PyErr_Occurred()) SWIG_fail;
44944 }
44945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44946 return resultobj;
44947 fail:
44948 return NULL;
44949 }
44950
44951
44952 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
44953 int argc;
44954 PyObject *argv[3];
44955 int ii;
44956
44957 argc = PyObject_Length(args);
44958 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44959 argv[ii] = PyTuple_GetItem(args,ii);
44960 }
44961 if (argc == 2) {
44962 int _v;
44963 {
44964 void *ptr;
44965 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44966 _v = 0;
44967 PyErr_Clear();
44968 } else {
44969 _v = 1;
44970 }
44971 }
44972 if (_v) {
44973 {
44974 void *ptr;
44975 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44976 _v = 0;
44977 PyErr_Clear();
44978 } else {
44979 _v = 1;
44980 }
44981 }
44982 if (_v) {
44983 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
44984 }
44985 }
44986 }
44987 if (argc == 2) {
44988 int _v;
44989 {
44990 void *ptr;
44991 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44992 _v = 0;
44993 PyErr_Clear();
44994 } else {
44995 _v = 1;
44996 }
44997 }
44998 if (_v) {
44999 {
45000 void *ptr;
45001 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
45002 _v = 0;
45003 PyErr_Clear();
45004 } else {
45005 _v = 1;
45006 }
45007 }
45008 if (_v) {
45009 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
45010 }
45011 }
45012 }
45013
45014 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
45015 return NULL;
45016 }
45017
45018
45019 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
45020 PyObject *resultobj = NULL;
45021 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45022 wxGBPosition *arg2 = 0 ;
45023 wxGBSizerItem *result;
45024 wxGBPosition temp2 ;
45025 PyObject * obj0 = 0 ;
45026 PyObject * obj1 = 0 ;
45027 char *kwnames[] = {
45028 (char *) "self",(char *) "pos", NULL
45029 };
45030
45031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
45032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45033 if (SWIG_arg_fail(1)) SWIG_fail;
45034 {
45035 arg2 = &temp2;
45036 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
45037 }
45038 {
45039 PyThreadState* __tstate = wxPyBeginAllowThreads();
45040 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
45041
45042 wxPyEndAllowThreads(__tstate);
45043 if (PyErr_Occurred()) SWIG_fail;
45044 }
45045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
45046 return resultobj;
45047 fail:
45048 return NULL;
45049 }
45050
45051
45052 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
45053 PyObject *resultobj = NULL;
45054 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45055 wxPoint *arg2 = 0 ;
45056 wxGBSizerItem *result;
45057 wxPoint temp2 ;
45058 PyObject * obj0 = 0 ;
45059 PyObject * obj1 = 0 ;
45060 char *kwnames[] = {
45061 (char *) "self",(char *) "pt", NULL
45062 };
45063
45064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
45065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45066 if (SWIG_arg_fail(1)) SWIG_fail;
45067 {
45068 arg2 = &temp2;
45069 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45070 }
45071 {
45072 PyThreadState* __tstate = wxPyBeginAllowThreads();
45073 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
45074
45075 wxPyEndAllowThreads(__tstate);
45076 if (PyErr_Occurred()) SWIG_fail;
45077 }
45078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
45079 return resultobj;
45080 fail:
45081 return NULL;
45082 }
45083
45084
45085 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
45086 PyObject *resultobj = NULL;
45087 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45088 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
45089 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
45090 bool result;
45091 PyObject * obj0 = 0 ;
45092 PyObject * obj1 = 0 ;
45093 PyObject * obj2 = 0 ;
45094 char *kwnames[] = {
45095 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
45096 };
45097
45098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
45099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45100 if (SWIG_arg_fail(1)) SWIG_fail;
45101 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45102 if (SWIG_arg_fail(2)) SWIG_fail;
45103 if (obj2) {
45104 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45105 if (SWIG_arg_fail(3)) SWIG_fail;
45106 }
45107 {
45108 PyThreadState* __tstate = wxPyBeginAllowThreads();
45109 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
45110
45111 wxPyEndAllowThreads(__tstate);
45112 if (PyErr_Occurred()) SWIG_fail;
45113 }
45114 {
45115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45116 }
45117 return resultobj;
45118 fail:
45119 return NULL;
45120 }
45121
45122
45123 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
45124 PyObject *resultobj = NULL;
45125 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45126 wxGBPosition *arg2 = 0 ;
45127 wxGBSpan *arg3 = 0 ;
45128 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
45129 bool result;
45130 wxGBPosition temp2 ;
45131 wxGBSpan temp3 ;
45132 PyObject * obj0 = 0 ;
45133 PyObject * obj1 = 0 ;
45134 PyObject * obj2 = 0 ;
45135 PyObject * obj3 = 0 ;
45136 char *kwnames[] = {
45137 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
45138 };
45139
45140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45142 if (SWIG_arg_fail(1)) SWIG_fail;
45143 {
45144 arg2 = &temp2;
45145 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
45146 }
45147 {
45148 arg3 = &temp3;
45149 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
45150 }
45151 if (obj3) {
45152 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45153 if (SWIG_arg_fail(4)) SWIG_fail;
45154 }
45155 {
45156 PyThreadState* __tstate = wxPyBeginAllowThreads();
45157 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
45158
45159 wxPyEndAllowThreads(__tstate);
45160 if (PyErr_Occurred()) SWIG_fail;
45161 }
45162 {
45163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45164 }
45165 return resultobj;
45166 fail:
45167 return NULL;
45168 }
45169
45170
45171 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
45172 PyObject *obj;
45173 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45174 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
45175 Py_INCREF(obj);
45176 return Py_BuildValue((char *)"");
45177 }
45178 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
45179 PyObject *resultobj = NULL;
45180 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45181 wxRelationship arg2 ;
45182 wxWindow *arg3 = (wxWindow *) 0 ;
45183 wxEdge arg4 ;
45184 int arg5 = (int) 0 ;
45185 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
45186 PyObject * obj0 = 0 ;
45187 PyObject * obj1 = 0 ;
45188 PyObject * obj2 = 0 ;
45189 PyObject * obj3 = 0 ;
45190 PyObject * obj4 = 0 ;
45191 PyObject * obj5 = 0 ;
45192 char *kwnames[] = {
45193 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
45194 };
45195
45196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
45197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45198 if (SWIG_arg_fail(1)) SWIG_fail;
45199 {
45200 arg2 = static_cast<wxRelationship >(SWIG_As_int(obj1));
45201 if (SWIG_arg_fail(2)) SWIG_fail;
45202 }
45203 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45204 if (SWIG_arg_fail(3)) SWIG_fail;
45205 {
45206 arg4 = static_cast<wxEdge >(SWIG_As_int(obj3));
45207 if (SWIG_arg_fail(4)) SWIG_fail;
45208 }
45209 if (obj4) {
45210 {
45211 arg5 = static_cast<int >(SWIG_As_int(obj4));
45212 if (SWIG_arg_fail(5)) SWIG_fail;
45213 }
45214 }
45215 if (obj5) {
45216 {
45217 arg6 = static_cast<int >(SWIG_As_int(obj5));
45218 if (SWIG_arg_fail(6)) SWIG_fail;
45219 }
45220 }
45221 {
45222 PyThreadState* __tstate = wxPyBeginAllowThreads();
45223 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
45224
45225 wxPyEndAllowThreads(__tstate);
45226 if (PyErr_Occurred()) SWIG_fail;
45227 }
45228 Py_INCREF(Py_None); resultobj = Py_None;
45229 return resultobj;
45230 fail:
45231 return NULL;
45232 }
45233
45234
45235 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
45236 PyObject *resultobj = NULL;
45237 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45238 wxWindow *arg2 = (wxWindow *) 0 ;
45239 int arg3 = (int) 0 ;
45240 PyObject * obj0 = 0 ;
45241 PyObject * obj1 = 0 ;
45242 PyObject * obj2 = 0 ;
45243 char *kwnames[] = {
45244 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45245 };
45246
45247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
45248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45249 if (SWIG_arg_fail(1)) SWIG_fail;
45250 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45251 if (SWIG_arg_fail(2)) SWIG_fail;
45252 if (obj2) {
45253 {
45254 arg3 = static_cast<int >(SWIG_As_int(obj2));
45255 if (SWIG_arg_fail(3)) SWIG_fail;
45256 }
45257 }
45258 {
45259 PyThreadState* __tstate = wxPyBeginAllowThreads();
45260 (arg1)->LeftOf(arg2,arg3);
45261
45262 wxPyEndAllowThreads(__tstate);
45263 if (PyErr_Occurred()) SWIG_fail;
45264 }
45265 Py_INCREF(Py_None); resultobj = Py_None;
45266 return resultobj;
45267 fail:
45268 return NULL;
45269 }
45270
45271
45272 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
45273 PyObject *resultobj = NULL;
45274 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45275 wxWindow *arg2 = (wxWindow *) 0 ;
45276 int arg3 = (int) 0 ;
45277 PyObject * obj0 = 0 ;
45278 PyObject * obj1 = 0 ;
45279 PyObject * obj2 = 0 ;
45280 char *kwnames[] = {
45281 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45282 };
45283
45284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
45285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45286 if (SWIG_arg_fail(1)) SWIG_fail;
45287 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45288 if (SWIG_arg_fail(2)) SWIG_fail;
45289 if (obj2) {
45290 {
45291 arg3 = static_cast<int >(SWIG_As_int(obj2));
45292 if (SWIG_arg_fail(3)) SWIG_fail;
45293 }
45294 }
45295 {
45296 PyThreadState* __tstate = wxPyBeginAllowThreads();
45297 (arg1)->RightOf(arg2,arg3);
45298
45299 wxPyEndAllowThreads(__tstate);
45300 if (PyErr_Occurred()) SWIG_fail;
45301 }
45302 Py_INCREF(Py_None); resultobj = Py_None;
45303 return resultobj;
45304 fail:
45305 return NULL;
45306 }
45307
45308
45309 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
45310 PyObject *resultobj = NULL;
45311 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45312 wxWindow *arg2 = (wxWindow *) 0 ;
45313 int arg3 = (int) 0 ;
45314 PyObject * obj0 = 0 ;
45315 PyObject * obj1 = 0 ;
45316 PyObject * obj2 = 0 ;
45317 char *kwnames[] = {
45318 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45319 };
45320
45321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
45322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45323 if (SWIG_arg_fail(1)) SWIG_fail;
45324 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45325 if (SWIG_arg_fail(2)) SWIG_fail;
45326 if (obj2) {
45327 {
45328 arg3 = static_cast<int >(SWIG_As_int(obj2));
45329 if (SWIG_arg_fail(3)) SWIG_fail;
45330 }
45331 }
45332 {
45333 PyThreadState* __tstate = wxPyBeginAllowThreads();
45334 (arg1)->Above(arg2,arg3);
45335
45336 wxPyEndAllowThreads(__tstate);
45337 if (PyErr_Occurred()) SWIG_fail;
45338 }
45339 Py_INCREF(Py_None); resultobj = Py_None;
45340 return resultobj;
45341 fail:
45342 return NULL;
45343 }
45344
45345
45346 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
45347 PyObject *resultobj = NULL;
45348 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45349 wxWindow *arg2 = (wxWindow *) 0 ;
45350 int arg3 = (int) 0 ;
45351 PyObject * obj0 = 0 ;
45352 PyObject * obj1 = 0 ;
45353 PyObject * obj2 = 0 ;
45354 char *kwnames[] = {
45355 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45356 };
45357
45358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
45359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45360 if (SWIG_arg_fail(1)) SWIG_fail;
45361 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45362 if (SWIG_arg_fail(2)) SWIG_fail;
45363 if (obj2) {
45364 {
45365 arg3 = static_cast<int >(SWIG_As_int(obj2));
45366 if (SWIG_arg_fail(3)) SWIG_fail;
45367 }
45368 }
45369 {
45370 PyThreadState* __tstate = wxPyBeginAllowThreads();
45371 (arg1)->Below(arg2,arg3);
45372
45373 wxPyEndAllowThreads(__tstate);
45374 if (PyErr_Occurred()) SWIG_fail;
45375 }
45376 Py_INCREF(Py_None); resultobj = Py_None;
45377 return resultobj;
45378 fail:
45379 return NULL;
45380 }
45381
45382
45383 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
45384 PyObject *resultobj = NULL;
45385 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45386 wxWindow *arg2 = (wxWindow *) 0 ;
45387 wxEdge arg3 ;
45388 int arg4 = (int) 0 ;
45389 PyObject * obj0 = 0 ;
45390 PyObject * obj1 = 0 ;
45391 PyObject * obj2 = 0 ;
45392 PyObject * obj3 = 0 ;
45393 char *kwnames[] = {
45394 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
45395 };
45396
45397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45399 if (SWIG_arg_fail(1)) SWIG_fail;
45400 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45401 if (SWIG_arg_fail(2)) SWIG_fail;
45402 {
45403 arg3 = static_cast<wxEdge >(SWIG_As_int(obj2));
45404 if (SWIG_arg_fail(3)) SWIG_fail;
45405 }
45406 if (obj3) {
45407 {
45408 arg4 = static_cast<int >(SWIG_As_int(obj3));
45409 if (SWIG_arg_fail(4)) SWIG_fail;
45410 }
45411 }
45412 {
45413 PyThreadState* __tstate = wxPyBeginAllowThreads();
45414 (arg1)->SameAs(arg2,arg3,arg4);
45415
45416 wxPyEndAllowThreads(__tstate);
45417 if (PyErr_Occurred()) SWIG_fail;
45418 }
45419 Py_INCREF(Py_None); resultobj = Py_None;
45420 return resultobj;
45421 fail:
45422 return NULL;
45423 }
45424
45425
45426 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
45427 PyObject *resultobj = NULL;
45428 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45429 wxWindow *arg2 = (wxWindow *) 0 ;
45430 wxEdge arg3 ;
45431 int arg4 ;
45432 PyObject * obj0 = 0 ;
45433 PyObject * obj1 = 0 ;
45434 PyObject * obj2 = 0 ;
45435 PyObject * obj3 = 0 ;
45436 char *kwnames[] = {
45437 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
45438 };
45439
45440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45442 if (SWIG_arg_fail(1)) SWIG_fail;
45443 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45444 if (SWIG_arg_fail(2)) SWIG_fail;
45445 {
45446 arg3 = static_cast<wxEdge >(SWIG_As_int(obj2));
45447 if (SWIG_arg_fail(3)) SWIG_fail;
45448 }
45449 {
45450 arg4 = static_cast<int >(SWIG_As_int(obj3));
45451 if (SWIG_arg_fail(4)) SWIG_fail;
45452 }
45453 {
45454 PyThreadState* __tstate = wxPyBeginAllowThreads();
45455 (arg1)->PercentOf(arg2,arg3,arg4);
45456
45457 wxPyEndAllowThreads(__tstate);
45458 if (PyErr_Occurred()) SWIG_fail;
45459 }
45460 Py_INCREF(Py_None); resultobj = Py_None;
45461 return resultobj;
45462 fail:
45463 return NULL;
45464 }
45465
45466
45467 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
45468 PyObject *resultobj = NULL;
45469 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45470 int arg2 ;
45471 PyObject * obj0 = 0 ;
45472 PyObject * obj1 = 0 ;
45473 char *kwnames[] = {
45474 (char *) "self",(char *) "val", NULL
45475 };
45476
45477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
45478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45479 if (SWIG_arg_fail(1)) SWIG_fail;
45480 {
45481 arg2 = static_cast<int >(SWIG_As_int(obj1));
45482 if (SWIG_arg_fail(2)) SWIG_fail;
45483 }
45484 {
45485 PyThreadState* __tstate = wxPyBeginAllowThreads();
45486 (arg1)->Absolute(arg2);
45487
45488 wxPyEndAllowThreads(__tstate);
45489 if (PyErr_Occurred()) SWIG_fail;
45490 }
45491 Py_INCREF(Py_None); resultobj = Py_None;
45492 return resultobj;
45493 fail:
45494 return NULL;
45495 }
45496
45497
45498 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
45499 PyObject *resultobj = NULL;
45500 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45501 PyObject * obj0 = 0 ;
45502 char *kwnames[] = {
45503 (char *) "self", NULL
45504 };
45505
45506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
45507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45508 if (SWIG_arg_fail(1)) SWIG_fail;
45509 {
45510 PyThreadState* __tstate = wxPyBeginAllowThreads();
45511 (arg1)->Unconstrained();
45512
45513 wxPyEndAllowThreads(__tstate);
45514 if (PyErr_Occurred()) SWIG_fail;
45515 }
45516 Py_INCREF(Py_None); resultobj = Py_None;
45517 return resultobj;
45518 fail:
45519 return NULL;
45520 }
45521
45522
45523 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
45524 PyObject *resultobj = NULL;
45525 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45526 PyObject * obj0 = 0 ;
45527 char *kwnames[] = {
45528 (char *) "self", NULL
45529 };
45530
45531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
45532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45533 if (SWIG_arg_fail(1)) SWIG_fail;
45534 {
45535 PyThreadState* __tstate = wxPyBeginAllowThreads();
45536 (arg1)->AsIs();
45537
45538 wxPyEndAllowThreads(__tstate);
45539 if (PyErr_Occurred()) SWIG_fail;
45540 }
45541 Py_INCREF(Py_None); resultobj = Py_None;
45542 return resultobj;
45543 fail:
45544 return NULL;
45545 }
45546
45547
45548 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
45549 PyObject *resultobj = NULL;
45550 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45551 wxWindow *result;
45552 PyObject * obj0 = 0 ;
45553 char *kwnames[] = {
45554 (char *) "self", NULL
45555 };
45556
45557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
45558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45559 if (SWIG_arg_fail(1)) SWIG_fail;
45560 {
45561 PyThreadState* __tstate = wxPyBeginAllowThreads();
45562 result = (wxWindow *)(arg1)->GetOtherWindow();
45563
45564 wxPyEndAllowThreads(__tstate);
45565 if (PyErr_Occurred()) SWIG_fail;
45566 }
45567 {
45568 resultobj = wxPyMake_wxObject(result, 0);
45569 }
45570 return resultobj;
45571 fail:
45572 return NULL;
45573 }
45574
45575
45576 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45577 PyObject *resultobj = NULL;
45578 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45579 wxEdge result;
45580 PyObject * obj0 = 0 ;
45581 char *kwnames[] = {
45582 (char *) "self", NULL
45583 };
45584
45585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
45586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45587 if (SWIG_arg_fail(1)) SWIG_fail;
45588 {
45589 PyThreadState* __tstate = wxPyBeginAllowThreads();
45590 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
45591
45592 wxPyEndAllowThreads(__tstate);
45593 if (PyErr_Occurred()) SWIG_fail;
45594 }
45595 resultobj = SWIG_From_int((result));
45596 return resultobj;
45597 fail:
45598 return NULL;
45599 }
45600
45601
45602 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45603 PyObject *resultobj = NULL;
45604 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45605 wxEdge arg2 ;
45606 PyObject * obj0 = 0 ;
45607 PyObject * obj1 = 0 ;
45608 char *kwnames[] = {
45609 (char *) "self",(char *) "which", NULL
45610 };
45611
45612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
45613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45614 if (SWIG_arg_fail(1)) SWIG_fail;
45615 {
45616 arg2 = static_cast<wxEdge >(SWIG_As_int(obj1));
45617 if (SWIG_arg_fail(2)) SWIG_fail;
45618 }
45619 {
45620 PyThreadState* __tstate = wxPyBeginAllowThreads();
45621 (arg1)->SetEdge(arg2);
45622
45623 wxPyEndAllowThreads(__tstate);
45624 if (PyErr_Occurred()) SWIG_fail;
45625 }
45626 Py_INCREF(Py_None); resultobj = Py_None;
45627 return resultobj;
45628 fail:
45629 return NULL;
45630 }
45631
45632
45633 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45634 PyObject *resultobj = NULL;
45635 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45636 int arg2 ;
45637 PyObject * obj0 = 0 ;
45638 PyObject * obj1 = 0 ;
45639 char *kwnames[] = {
45640 (char *) "self",(char *) "v", NULL
45641 };
45642
45643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
45644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45645 if (SWIG_arg_fail(1)) SWIG_fail;
45646 {
45647 arg2 = static_cast<int >(SWIG_As_int(obj1));
45648 if (SWIG_arg_fail(2)) SWIG_fail;
45649 }
45650 {
45651 PyThreadState* __tstate = wxPyBeginAllowThreads();
45652 (arg1)->SetValue(arg2);
45653
45654 wxPyEndAllowThreads(__tstate);
45655 if (PyErr_Occurred()) SWIG_fail;
45656 }
45657 Py_INCREF(Py_None); resultobj = Py_None;
45658 return resultobj;
45659 fail:
45660 return NULL;
45661 }
45662
45663
45664 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45665 PyObject *resultobj = NULL;
45666 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45667 int result;
45668 PyObject * obj0 = 0 ;
45669 char *kwnames[] = {
45670 (char *) "self", NULL
45671 };
45672
45673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
45674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45675 if (SWIG_arg_fail(1)) SWIG_fail;
45676 {
45677 PyThreadState* __tstate = wxPyBeginAllowThreads();
45678 result = (int)(arg1)->GetMargin();
45679
45680 wxPyEndAllowThreads(__tstate);
45681 if (PyErr_Occurred()) SWIG_fail;
45682 }
45683 {
45684 resultobj = SWIG_From_int(static_cast<int >(result));
45685 }
45686 return resultobj;
45687 fail:
45688 return NULL;
45689 }
45690
45691
45692 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45693 PyObject *resultobj = NULL;
45694 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45695 int arg2 ;
45696 PyObject * obj0 = 0 ;
45697 PyObject * obj1 = 0 ;
45698 char *kwnames[] = {
45699 (char *) "self",(char *) "m", NULL
45700 };
45701
45702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
45703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45704 if (SWIG_arg_fail(1)) SWIG_fail;
45705 {
45706 arg2 = static_cast<int >(SWIG_As_int(obj1));
45707 if (SWIG_arg_fail(2)) SWIG_fail;
45708 }
45709 {
45710 PyThreadState* __tstate = wxPyBeginAllowThreads();
45711 (arg1)->SetMargin(arg2);
45712
45713 wxPyEndAllowThreads(__tstate);
45714 if (PyErr_Occurred()) SWIG_fail;
45715 }
45716 Py_INCREF(Py_None); resultobj = Py_None;
45717 return resultobj;
45718 fail:
45719 return NULL;
45720 }
45721
45722
45723 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45724 PyObject *resultobj = NULL;
45725 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45726 int result;
45727 PyObject * obj0 = 0 ;
45728 char *kwnames[] = {
45729 (char *) "self", NULL
45730 };
45731
45732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
45733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45734 if (SWIG_arg_fail(1)) SWIG_fail;
45735 {
45736 PyThreadState* __tstate = wxPyBeginAllowThreads();
45737 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
45738
45739 wxPyEndAllowThreads(__tstate);
45740 if (PyErr_Occurred()) SWIG_fail;
45741 }
45742 {
45743 resultobj = SWIG_From_int(static_cast<int >(result));
45744 }
45745 return resultobj;
45746 fail:
45747 return NULL;
45748 }
45749
45750
45751 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
45752 PyObject *resultobj = NULL;
45753 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45754 int result;
45755 PyObject * obj0 = 0 ;
45756 char *kwnames[] = {
45757 (char *) "self", NULL
45758 };
45759
45760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
45761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45762 if (SWIG_arg_fail(1)) SWIG_fail;
45763 {
45764 PyThreadState* __tstate = wxPyBeginAllowThreads();
45765 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
45766
45767 wxPyEndAllowThreads(__tstate);
45768 if (PyErr_Occurred()) SWIG_fail;
45769 }
45770 {
45771 resultobj = SWIG_From_int(static_cast<int >(result));
45772 }
45773 return resultobj;
45774 fail:
45775 return NULL;
45776 }
45777
45778
45779 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45780 PyObject *resultobj = NULL;
45781 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45782 int result;
45783 PyObject * obj0 = 0 ;
45784 char *kwnames[] = {
45785 (char *) "self", NULL
45786 };
45787
45788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
45789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45790 if (SWIG_arg_fail(1)) SWIG_fail;
45791 {
45792 PyThreadState* __tstate = wxPyBeginAllowThreads();
45793 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
45794
45795 wxPyEndAllowThreads(__tstate);
45796 if (PyErr_Occurred()) SWIG_fail;
45797 }
45798 {
45799 resultobj = SWIG_From_int(static_cast<int >(result));
45800 }
45801 return resultobj;
45802 fail:
45803 return NULL;
45804 }
45805
45806
45807 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45808 PyObject *resultobj = NULL;
45809 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45810 bool result;
45811 PyObject * obj0 = 0 ;
45812 char *kwnames[] = {
45813 (char *) "self", NULL
45814 };
45815
45816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
45817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45818 if (SWIG_arg_fail(1)) SWIG_fail;
45819 {
45820 PyThreadState* __tstate = wxPyBeginAllowThreads();
45821 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
45822
45823 wxPyEndAllowThreads(__tstate);
45824 if (PyErr_Occurred()) SWIG_fail;
45825 }
45826 {
45827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45828 }
45829 return resultobj;
45830 fail:
45831 return NULL;
45832 }
45833
45834
45835 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45836 PyObject *resultobj = NULL;
45837 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45838 bool arg2 ;
45839 PyObject * obj0 = 0 ;
45840 PyObject * obj1 = 0 ;
45841 char *kwnames[] = {
45842 (char *) "self",(char *) "d", NULL
45843 };
45844
45845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
45846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45847 if (SWIG_arg_fail(1)) SWIG_fail;
45848 {
45849 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
45850 if (SWIG_arg_fail(2)) SWIG_fail;
45851 }
45852 {
45853 PyThreadState* __tstate = wxPyBeginAllowThreads();
45854 (arg1)->SetDone(arg2);
45855
45856 wxPyEndAllowThreads(__tstate);
45857 if (PyErr_Occurred()) SWIG_fail;
45858 }
45859 Py_INCREF(Py_None); resultobj = Py_None;
45860 return resultobj;
45861 fail:
45862 return NULL;
45863 }
45864
45865
45866 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45867 PyObject *resultobj = NULL;
45868 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45869 wxRelationship result;
45870 PyObject * obj0 = 0 ;
45871 char *kwnames[] = {
45872 (char *) "self", NULL
45873 };
45874
45875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
45876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45877 if (SWIG_arg_fail(1)) SWIG_fail;
45878 {
45879 PyThreadState* __tstate = wxPyBeginAllowThreads();
45880 result = (wxRelationship)(arg1)->GetRelationship();
45881
45882 wxPyEndAllowThreads(__tstate);
45883 if (PyErr_Occurred()) SWIG_fail;
45884 }
45885 resultobj = SWIG_From_int((result));
45886 return resultobj;
45887 fail:
45888 return NULL;
45889 }
45890
45891
45892 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45893 PyObject *resultobj = NULL;
45894 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45895 wxRelationship arg2 ;
45896 PyObject * obj0 = 0 ;
45897 PyObject * obj1 = 0 ;
45898 char *kwnames[] = {
45899 (char *) "self",(char *) "r", NULL
45900 };
45901
45902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
45903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45904 if (SWIG_arg_fail(1)) SWIG_fail;
45905 {
45906 arg2 = static_cast<wxRelationship >(SWIG_As_int(obj1));
45907 if (SWIG_arg_fail(2)) SWIG_fail;
45908 }
45909 {
45910 PyThreadState* __tstate = wxPyBeginAllowThreads();
45911 (arg1)->SetRelationship(arg2);
45912
45913 wxPyEndAllowThreads(__tstate);
45914 if (PyErr_Occurred()) SWIG_fail;
45915 }
45916 Py_INCREF(Py_None); resultobj = Py_None;
45917 return resultobj;
45918 fail:
45919 return NULL;
45920 }
45921
45922
45923 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
45924 PyObject *resultobj = NULL;
45925 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45926 wxWindow *arg2 = (wxWindow *) 0 ;
45927 bool result;
45928 PyObject * obj0 = 0 ;
45929 PyObject * obj1 = 0 ;
45930 char *kwnames[] = {
45931 (char *) "self",(char *) "otherW", NULL
45932 };
45933
45934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
45935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45936 if (SWIG_arg_fail(1)) SWIG_fail;
45937 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45938 if (SWIG_arg_fail(2)) SWIG_fail;
45939 {
45940 PyThreadState* __tstate = wxPyBeginAllowThreads();
45941 result = (bool)(arg1)->ResetIfWin(arg2);
45942
45943 wxPyEndAllowThreads(__tstate);
45944 if (PyErr_Occurred()) SWIG_fail;
45945 }
45946 {
45947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45948 }
45949 return resultobj;
45950 fail:
45951 return NULL;
45952 }
45953
45954
45955 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
45956 PyObject *resultobj = NULL;
45957 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45958 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
45959 wxWindow *arg3 = (wxWindow *) 0 ;
45960 bool result;
45961 PyObject * obj0 = 0 ;
45962 PyObject * obj1 = 0 ;
45963 PyObject * obj2 = 0 ;
45964 char *kwnames[] = {
45965 (char *) "self",(char *) "constraints",(char *) "win", NULL
45966 };
45967
45968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
45969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45970 if (SWIG_arg_fail(1)) SWIG_fail;
45971 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45972 if (SWIG_arg_fail(2)) SWIG_fail;
45973 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45974 if (SWIG_arg_fail(3)) SWIG_fail;
45975 {
45976 PyThreadState* __tstate = wxPyBeginAllowThreads();
45977 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
45978
45979 wxPyEndAllowThreads(__tstate);
45980 if (PyErr_Occurred()) SWIG_fail;
45981 }
45982 {
45983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45984 }
45985 return resultobj;
45986 fail:
45987 return NULL;
45988 }
45989
45990
45991 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45992 PyObject *resultobj = NULL;
45993 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45994 wxEdge arg2 ;
45995 wxWindow *arg3 = (wxWindow *) 0 ;
45996 wxWindow *arg4 = (wxWindow *) 0 ;
45997 int result;
45998 PyObject * obj0 = 0 ;
45999 PyObject * obj1 = 0 ;
46000 PyObject * obj2 = 0 ;
46001 PyObject * obj3 = 0 ;
46002 char *kwnames[] = {
46003 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
46004 };
46005
46006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
46007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
46008 if (SWIG_arg_fail(1)) SWIG_fail;
46009 {
46010 arg2 = static_cast<wxEdge >(SWIG_As_int(obj1));
46011 if (SWIG_arg_fail(2)) SWIG_fail;
46012 }
46013 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46014 if (SWIG_arg_fail(3)) SWIG_fail;
46015 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46016 if (SWIG_arg_fail(4)) SWIG_fail;
46017 {
46018 PyThreadState* __tstate = wxPyBeginAllowThreads();
46019 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
46020
46021 wxPyEndAllowThreads(__tstate);
46022 if (PyErr_Occurred()) SWIG_fail;
46023 }
46024 {
46025 resultobj = SWIG_From_int(static_cast<int >(result));
46026 }
46027 return resultobj;
46028 fail:
46029 return NULL;
46030 }
46031
46032
46033 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
46034 PyObject *obj;
46035 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
46036 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
46037 Py_INCREF(obj);
46038 return Py_BuildValue((char *)"");
46039 }
46040 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
46041 PyObject *resultobj = NULL;
46042 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46043 wxIndividualLayoutConstraint *result;
46044 PyObject * obj0 = 0 ;
46045 char *kwnames[] = {
46046 (char *) "self", NULL
46047 };
46048
46049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
46050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46051 if (SWIG_arg_fail(1)) SWIG_fail;
46052 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
46053
46054 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46055 return resultobj;
46056 fail:
46057 return NULL;
46058 }
46059
46060
46061 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
46062 PyObject *resultobj = NULL;
46063 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46064 wxIndividualLayoutConstraint *result;
46065 PyObject * obj0 = 0 ;
46066 char *kwnames[] = {
46067 (char *) "self", NULL
46068 };
46069
46070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
46071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46072 if (SWIG_arg_fail(1)) SWIG_fail;
46073 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
46074
46075 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46076 return resultobj;
46077 fail:
46078 return NULL;
46079 }
46080
46081
46082 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
46083 PyObject *resultobj = NULL;
46084 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46085 wxIndividualLayoutConstraint *result;
46086 PyObject * obj0 = 0 ;
46087 char *kwnames[] = {
46088 (char *) "self", NULL
46089 };
46090
46091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
46092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46093 if (SWIG_arg_fail(1)) SWIG_fail;
46094 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
46095
46096 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46097 return resultobj;
46098 fail:
46099 return NULL;
46100 }
46101
46102
46103 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
46104 PyObject *resultobj = NULL;
46105 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46106 wxIndividualLayoutConstraint *result;
46107 PyObject * obj0 = 0 ;
46108 char *kwnames[] = {
46109 (char *) "self", NULL
46110 };
46111
46112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
46113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46114 if (SWIG_arg_fail(1)) SWIG_fail;
46115 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
46116
46117 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46118 return resultobj;
46119 fail:
46120 return NULL;
46121 }
46122
46123
46124 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
46125 PyObject *resultobj = NULL;
46126 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46127 wxIndividualLayoutConstraint *result;
46128 PyObject * obj0 = 0 ;
46129 char *kwnames[] = {
46130 (char *) "self", NULL
46131 };
46132
46133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
46134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46135 if (SWIG_arg_fail(1)) SWIG_fail;
46136 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
46137
46138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46139 return resultobj;
46140 fail:
46141 return NULL;
46142 }
46143
46144
46145 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
46146 PyObject *resultobj = NULL;
46147 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46148 wxIndividualLayoutConstraint *result;
46149 PyObject * obj0 = 0 ;
46150 char *kwnames[] = {
46151 (char *) "self", NULL
46152 };
46153
46154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
46155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46156 if (SWIG_arg_fail(1)) SWIG_fail;
46157 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
46158
46159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46160 return resultobj;
46161 fail:
46162 return NULL;
46163 }
46164
46165
46166 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
46167 PyObject *resultobj = NULL;
46168 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46169 wxIndividualLayoutConstraint *result;
46170 PyObject * obj0 = 0 ;
46171 char *kwnames[] = {
46172 (char *) "self", NULL
46173 };
46174
46175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
46176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46177 if (SWIG_arg_fail(1)) SWIG_fail;
46178 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
46179
46180 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46181 return resultobj;
46182 fail:
46183 return NULL;
46184 }
46185
46186
46187 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
46188 PyObject *resultobj = NULL;
46189 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46190 wxIndividualLayoutConstraint *result;
46191 PyObject * obj0 = 0 ;
46192 char *kwnames[] = {
46193 (char *) "self", NULL
46194 };
46195
46196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
46197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46198 if (SWIG_arg_fail(1)) SWIG_fail;
46199 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
46200
46201 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46202 return resultobj;
46203 fail:
46204 return NULL;
46205 }
46206
46207
46208 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
46209 PyObject *resultobj = NULL;
46210 wxLayoutConstraints *result;
46211 char *kwnames[] = {
46212 NULL
46213 };
46214
46215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
46216 {
46217 PyThreadState* __tstate = wxPyBeginAllowThreads();
46218 result = (wxLayoutConstraints *)new wxLayoutConstraints();
46219
46220 wxPyEndAllowThreads(__tstate);
46221 if (PyErr_Occurred()) SWIG_fail;
46222 }
46223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
46224 return resultobj;
46225 fail:
46226 return NULL;
46227 }
46228
46229
46230 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
46231 PyObject *resultobj = NULL;
46232 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46233 wxWindow *arg2 = (wxWindow *) 0 ;
46234 int *arg3 = (int *) 0 ;
46235 bool result;
46236 int temp3 ;
46237 int res3 = 0 ;
46238 PyObject * obj0 = 0 ;
46239 PyObject * obj1 = 0 ;
46240 char *kwnames[] = {
46241 (char *) "self",(char *) "win", NULL
46242 };
46243
46244 arg3 = &temp3; res3 = SWIG_NEWOBJ;
46245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
46246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46247 if (SWIG_arg_fail(1)) SWIG_fail;
46248 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46249 if (SWIG_arg_fail(2)) SWIG_fail;
46250 {
46251 PyThreadState* __tstate = wxPyBeginAllowThreads();
46252 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
46253
46254 wxPyEndAllowThreads(__tstate);
46255 if (PyErr_Occurred()) SWIG_fail;
46256 }
46257 {
46258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46259 }
46260 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
46261 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
46262 return resultobj;
46263 fail:
46264 return NULL;
46265 }
46266
46267
46268 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
46269 PyObject *resultobj = NULL;
46270 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46271 bool result;
46272 PyObject * obj0 = 0 ;
46273 char *kwnames[] = {
46274 (char *) "self", NULL
46275 };
46276
46277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
46278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46279 if (SWIG_arg_fail(1)) SWIG_fail;
46280 {
46281 PyThreadState* __tstate = wxPyBeginAllowThreads();
46282 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
46283
46284 wxPyEndAllowThreads(__tstate);
46285 if (PyErr_Occurred()) SWIG_fail;
46286 }
46287 {
46288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46289 }
46290 return resultobj;
46291 fail:
46292 return NULL;
46293 }
46294
46295
46296 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
46297 PyObject *obj;
46298 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
46299 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
46300 Py_INCREF(obj);
46301 return Py_BuildValue((char *)"");
46302 }
46303 static PyMethodDef SwigMethods[] = {
46304 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
46305 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
46306 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
46309 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
46330 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
46343 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
46358 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
46412 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
46440 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
46459 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
46461 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
46469 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
46470 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
46482 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
46494 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
46498 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
46504 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
46514 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
46524 { (char *)"new_PyImageHandler", (PyCFunction) _wrap_new_PyImageHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
46527 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
46534 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"Image_RGBValue_red_set", (PyCFunction) _wrap_Image_RGBValue_red_set, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"Image_RGBValue_red_get", (PyCFunction) _wrap_Image_RGBValue_red_get, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"Image_RGBValue_green_set", (PyCFunction) _wrap_Image_RGBValue_green_set, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"Image_RGBValue_green_get", (PyCFunction) _wrap_Image_RGBValue_green_get, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"Image_RGBValue_blue_set", (PyCFunction) _wrap_Image_RGBValue_blue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"Image_RGBValue_blue_get", (PyCFunction) _wrap_Image_RGBValue_blue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
46542 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"Image_HSVValue_hue_set", (PyCFunction) _wrap_Image_HSVValue_hue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"Image_HSVValue_hue_get", (PyCFunction) _wrap_Image_HSVValue_hue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"Image_HSVValue_saturation_set", (PyCFunction) _wrap_Image_HSVValue_saturation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"Image_HSVValue_saturation_get", (PyCFunction) _wrap_Image_HSVValue_saturation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"Image_HSVValue_value_set", (PyCFunction) _wrap_Image_HSVValue_value_set, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"Image_HSVValue_value_get", (PyCFunction) _wrap_Image_HSVValue_value_get, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
46550 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46603 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46604 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
46612 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
46617 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46624 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46626 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
46634 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
46636 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
46638 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46639 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
46640 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
46642 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46643 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
46644 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46645 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
46646 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46647 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
46648 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46649 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
46650 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46651 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
46652 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46653 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
46654 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46655 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
46656 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
46657 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
46658 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46659 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46660 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46661 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46662 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46663 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46664 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46665 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46666 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46667 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46668 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
46669 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
46670 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46671 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
46672 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46673 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
46674 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46675 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46676 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46677 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46678 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46679 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46680 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46681 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46682 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46683 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
46684 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
46685 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
46686 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46687 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46688 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46689 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
46690 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46691 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46692 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
46693 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46694 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46695 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
46696 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46697 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46698 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46699 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46700 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46701 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46702 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46703 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46704 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46705 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46706 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46707 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
46708 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46709 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46710 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
46711 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
46712 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
46713 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46714 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46715 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46716 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46717 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46718 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
46719 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46720 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46721 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46722 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46723 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46724 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
46725 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46726 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
46727 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
46728 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46729 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
46730 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
46731 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46732 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
46733 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46734 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46735 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46736 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46737 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46738 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46739 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
46740 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
46741 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
46742 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
46743 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
46744 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46745 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46746 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46747 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46748 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46749 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46750 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
46751 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
46752 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
46753 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
46754 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46755 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46756 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46757 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46758 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46759 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
46760 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
46761 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
46762 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
46763 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46764 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46765 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46766 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46767 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46768 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46769 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46770 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46771 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46772 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46773 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46774 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46775 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46776 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46777 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46778 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46779 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46780 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46781 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46782 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46783 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
46784 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
46785 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
46786 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
46787 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
46788 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46789 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46790 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46791 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46792 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46793 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46794 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
46795 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46796 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46797 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46798 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46799 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46800 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46801 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
46802 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46803 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46804 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46805 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46806 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46807 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46808 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46809 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46810 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46811 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46812 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46813 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46814 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46815 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46816 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46817 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46818 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46819 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46820 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46821 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46822 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46823 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46824 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46825 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46826 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46827 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46828 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
46829 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
46830 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
46831 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46832 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46833 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46834 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46835 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46836 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
46837 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
46838 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
46839 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
46840 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
46841 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46842 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46843 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46844 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46845 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46846 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
46847 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46848 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
46849 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46850 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
46851 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46852 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
46853 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
46854 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46855 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46856 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46857 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
46858 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46859 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46860 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
46861 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46862 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46863 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
46864 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46865 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
46866 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46867 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
46868 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
46869 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46870 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
46871 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46872 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46873 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46874 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46875 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46876 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46877 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46878 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
46879 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46880 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46881 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46882 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
46883 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46884 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
46885 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
46886 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46887 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
46888 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46889 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46890 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46891 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
46892 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46893 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46894 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46895 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46896 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
46897 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46898 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46899 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46900 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46901 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46902 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46903 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46904 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
46905 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
46906 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46907 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46908 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
46909 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46910 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
46911 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46912 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46913 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
46914 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46915 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
46916 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46917 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46918 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46919 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
46920 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46921 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46922 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46923 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
46924 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46925 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46926 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46927 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46928 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46929 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46930 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46931 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46932 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46933 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46934 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
46935 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46936 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46937 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
46938 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46939 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46940 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
46941 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46942 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46943 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46944 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
46945 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46946 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
46947 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
46948 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46949 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46950 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
46951 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
46952 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46953 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46954 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46955 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46956 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
46957 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46958 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46959 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46960 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46961 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
46962 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46963 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46964 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46965 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
46966 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46967 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46968 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46969 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46970 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46971 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46972 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46973 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46974 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46975 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
46976 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46977 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46978 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46979 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46980 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46981 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46982 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46983 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46984 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46985 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46986 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46987 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
46988 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46989 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46990 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46991 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46992 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46993 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46994 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46995 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46996 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46997 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46998 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46999 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47000 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47001 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47002 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
47003 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
47004 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47005 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47006 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47007 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
47008 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
47009 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
47010 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
47011 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
47012 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
47013 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
47014 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
47015 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
47016 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47017 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
47018 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
47019 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
47020 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
47021 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
47022 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
47023 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
47024 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
47025 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
47026 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
47027 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
47028 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
47029 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
47030 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
47031 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
47032 { (char *)"delete_EventLoopActivator", (PyCFunction) _wrap_delete_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
47033 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
47034 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
47035 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
47036 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47037 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
47038 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
47039 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
47040 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
47041 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47042 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47043 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
47044 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
47045 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
47046 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47047 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47048 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
47049 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
47050 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
47051 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
47052 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
47053 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
47054 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
47055 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
47056 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47057 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
47058 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
47059 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
47060 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47061 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
47062 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47063 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47064 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
47065 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
47066 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
47067 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
47068 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
47069 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
47070 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
47071 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
47072 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
47073 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47074 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
47075 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47076 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
47077 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
47078 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
47079 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
47080 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
47081 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
47082 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
47083 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
47084 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47085 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47086 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47087 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47088 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47089 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47090 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
47091 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47092 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
47093 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47094 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47095 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47096 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47097 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47098 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
47099 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47100 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
47101 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
47102 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
47103 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
47104 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
47105 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47106 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
47107 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47108 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
47109 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
47110 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47111 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47112 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
47113 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47114 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47115 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47116 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47117 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47118 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
47119 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47120 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47121 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47122 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47123 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
47124 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47125 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
47126 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47127 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47128 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47129 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47130 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47131 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
47132 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47133 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47134 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
47135 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47136 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47137 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47138 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
47139 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47140 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47141 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
47142 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47143 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47144 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47145 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
47146 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
47147 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
47148 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47149 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47150 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
47151 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
47152 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
47153 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
47154 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
47155 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
47156 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
47157 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47158 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47159 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47160 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47161 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47162 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47163 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47164 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
47165 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47166 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47167 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47168 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47169 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47170 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
47171 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
47172 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
47173 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
47174 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
47175 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
47176 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47177 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47178 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
47179 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
47180 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
47181 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
47182 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
47183 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
47184 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
47185 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
47186 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
47187 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
47188 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
47189 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
47190 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
47191 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47192 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
47193 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47194 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
47195 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47196 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47197 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47198 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47199 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47200 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47201 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47202 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47203 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47204 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
47205 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47206 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47207 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
47208 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
47209 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
47210 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47211 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
47212 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47213 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
47214 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
47215 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47216 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47217 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
47218 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
47219 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
47220 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
47221 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
47222 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
47223 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
47224 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
47225 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
47226 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
47227 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
47228 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47229 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47230 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47231 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47232 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
47233 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
47234 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
47235 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
47236 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
47237 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
47238 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47239 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
47240 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
47241 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
47242 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
47243 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
47244 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
47245 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
47246 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
47247 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
47248 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
47249 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
47250 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
47251 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
47252 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
47253 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
47254 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47255 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47256 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
47257 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
47258 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47259 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47260 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
47261 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47262 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47263 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47264 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47265 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
47266 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
47267 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
47268 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
47269 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47270 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
47271 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47272 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
47273 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
47274 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
47275 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47276 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47277 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47278 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47279 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
47280 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
47281 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
47282 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47283 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47284 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
47285 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
47286 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47287 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47288 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47289 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47290 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47291 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
47292 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
47293 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47294 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47295 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47296 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47297 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47298 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47299 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47300 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47301 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47302 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47303 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47304 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47305 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47306 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
47307 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47308 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
47309 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
47310 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
47311 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
47312 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
47313 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
47314 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
47315 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
47316 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47317 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47318 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47319 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47320 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47321 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47322 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47323 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47324 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47325 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
47326 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
47327 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47328 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47329 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47330 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47331 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47332 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
47333 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
47334 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47335 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47336 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47337 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47338 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47339 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
47340 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
47341 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47342 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47343 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
47344 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47345 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
47346 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47347 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
47348 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
47349 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
47350 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
47351 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47352 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
47353 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47354 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47355 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47356 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47357 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47358 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47359 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47360 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47361 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47362 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
47363 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47364 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47365 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47366 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47367 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_GetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47368 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
47369 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47370 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47371 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47372 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
47373 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
47374 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47375 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
47376 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47377 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
47378 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
47379 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47380 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47381 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47382 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47383 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47384 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47385 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47386 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47387 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47388 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47389 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47390 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
47391 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47392 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47393 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47394 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47395 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47396 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47397 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47398 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47399 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47400 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47401 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47402 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47403 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
47404 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47405 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47406 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47407 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47408 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47409 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47410 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47411 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47412 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
47413 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
47414 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
47415 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
47416 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
47417 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47418 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47419 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47420 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
47421 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47422 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
47423 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47424 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47425 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47426 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47427 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47428 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
47429 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
47430 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
47431 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
47432 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
47433 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
47434 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47435 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47436 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47437 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47438 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
47439 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
47440 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
47441 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47442 { (char *)"delete_SizerItem", (PyCFunction) _wrap_delete_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47443 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47444 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47445 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47446 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47447 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47448 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47449 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47450 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47451 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47452 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47453 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
47454 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
47455 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
47456 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47457 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47458 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47459 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47460 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47461 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47462 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47463 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47464 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47465 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47466 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47467 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47468 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47469 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47470 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47471 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47472 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47473 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47474 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47475 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47476 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47477 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47478 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47479 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
47480 { (char *)"delete_Sizer", (PyCFunction) _wrap_delete_Sizer, METH_VARARGS | METH_KEYWORDS, NULL},
47481 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47482 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47483 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47484 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47485 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47486 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47487 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
47488 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47489 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47490 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47491 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47492 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47493 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47494 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47495 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47496 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47497 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
47498 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47499 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47500 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
47501 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
47502 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47503 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47504 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47505 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47506 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47507 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47508 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47509 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
47510 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
47511 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
47512 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47513 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
47514 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47515 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47516 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47517 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
47518 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47519 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
47520 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
47521 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47522 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47523 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47524 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47525 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47526 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47527 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47528 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47529 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47530 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
47531 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47532 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47533 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47534 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47535 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47536 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47537 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47538 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47539 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47540 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
47541 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
47542 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
47543 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47544 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
47545 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
47546 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47547 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47548 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47549 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47550 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
47551 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47552 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47553 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
47554 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
47555 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47556 { (char *)"delete_GBPosition", (PyCFunction) _wrap_delete_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47557 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47558 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47559 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47560 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47561 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47562 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47563 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47564 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47565 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
47566 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47567 { (char *)"delete_GBSpan", (PyCFunction) _wrap_delete_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47568 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47569 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47570 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47571 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47572 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47573 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47574 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47575 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47576 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
47577 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47578 { (char *)"delete_GBSizerItem", (PyCFunction) _wrap_delete_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47579 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47580 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47581 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47582 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47583 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47584 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47585 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47586 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
47587 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
47588 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
47589 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47590 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47591 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
47592 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47593 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47594 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47595 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47596 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47597 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47598 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
47599 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
47600 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
47601 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
47602 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
47603 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47604 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47605 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
47606 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
47607 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
47608 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47609 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
47610 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
47611 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
47612 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
47613 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
47614 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
47615 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
47616 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
47617 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
47618 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47619 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47620 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47621 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47622 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47623 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47624 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47625 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
47626 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47627 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47628 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47629 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47630 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47631 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
47632 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
47633 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47634 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
47635 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
47636 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
47637 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
47638 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
47639 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
47640 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
47641 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
47642 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
47643 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47644 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47645 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
47646 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
47647 { NULL, NULL, 0, NULL }
47648 };
47649
47650
47651 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
47652
47653 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
47654 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
47655 }
47656 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
47657 return (void *)((wxSizer *) ((wxBoxSizer *) x));
47658 }
47659 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
47660 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
47661 }
47662 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
47663 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47664 }
47665 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
47666 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47667 }
47668 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
47669 return (void *)((wxSizer *) ((wxGridSizer *) x));
47670 }
47671 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
47672 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
47673 }
47674 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
47675 return (void *)((wxSizer *) ((wxPySizer *) x));
47676 }
47677 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
47678 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
47679 }
47680 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
47681 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47682 }
47683 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
47684 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
47685 }
47686 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
47687 return (void *)((wxEvent *) ((wxMenuEvent *) x));
47688 }
47689 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
47690 return (void *)((wxEvent *) ((wxCloseEvent *) x));
47691 }
47692 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
47693 return (void *)((wxEvent *) ((wxMouseEvent *) x));
47694 }
47695 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
47696 return (void *)((wxEvent *) ((wxEraseEvent *) x));
47697 }
47698 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
47699 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
47700 }
47701 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
47702 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
47703 }
47704 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
47705 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
47706 }
47707 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
47708 return (void *)((wxEvent *) ((wxPyEvent *) x));
47709 }
47710 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
47711 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
47712 }
47713 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
47714 return (void *)((wxEvent *) ((wxIdleEvent *) x));
47715 }
47716 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
47717 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
47718 }
47719 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
47720 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
47721 }
47722 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
47723 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
47724 }
47725 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
47726 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
47727 }
47728 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
47729 return (void *)((wxEvent *) ((wxActivateEvent *) x));
47730 }
47731 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
47732 return (void *)((wxEvent *) ((wxSizeEvent *) x));
47733 }
47734 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
47735 return (void *)((wxEvent *) ((wxMoveEvent *) x));
47736 }
47737 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
47738 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
47739 }
47740 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
47741 return (void *)((wxEvent *) ((wxPaintEvent *) x));
47742 }
47743 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
47744 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
47745 }
47746 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
47747 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
47748 }
47749 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
47750 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
47751 }
47752 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
47753 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
47754 }
47755 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
47756 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47757 }
47758 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
47759 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
47760 }
47761 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
47762 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
47763 }
47764 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
47765 return (void *)((wxEvent *) ((wxFocusEvent *) x));
47766 }
47767 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
47768 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
47769 }
47770 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
47771 return (void *)((wxEvent *) ((wxShowEvent *) x));
47772 }
47773 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
47774 return (void *)((wxEvent *) ((wxCommandEvent *) x));
47775 }
47776 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
47777 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
47778 }
47779 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
47780 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47781 }
47782 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
47783 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
47784 }
47785 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
47786 return (void *)((wxEvent *) ((wxKeyEvent *) x));
47787 }
47788 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
47789 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
47790 }
47791 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
47792 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
47793 }
47794 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
47795 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
47796 }
47797 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
47798 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
47799 }
47800 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
47801 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
47802 }
47803 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
47804 return (void *)((wxControl *) ((wxControlWithItems *) x));
47805 }
47806 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
47807 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
47808 }
47809 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
47810 return (void *)((wxEvtHandler *) ((wxWindow *) x));
47811 }
47812 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
47813 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47814 }
47815 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
47816 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
47817 }
47818 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
47819 return (void *)((wxEvtHandler *) ((wxValidator *) x));
47820 }
47821 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
47822 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
47823 }
47824 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
47825 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
47826 }
47827 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
47828 return (void *)((wxEvtHandler *) ((wxMenu *) x));
47829 }
47830 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
47831 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
47832 }
47833 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
47834 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
47835 }
47836 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
47837 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
47838 }
47839 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
47840 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
47841 }
47842 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
47843 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
47844 }
47845 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
47846 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47847 }
47848 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
47849 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
47850 }
47851 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
47852 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
47853 }
47854 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
47855 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
47856 }
47857 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
47858 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47859 }
47860 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
47861 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47862 }
47863 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
47864 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
47865 }
47866 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
47867 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
47868 }
47869 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
47870 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
47871 }
47872 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
47873 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
47874 }
47875 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
47876 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
47877 }
47878 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
47879 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
47880 }
47881 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
47882 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
47883 }
47884 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
47885 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
47886 }
47887 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
47888 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
47889 }
47890 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
47891 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
47892 }
47893 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
47894 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
47895 }
47896 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
47897 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
47898 }
47899 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
47900 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
47901 }
47902 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
47903 return (void *)((wxObject *) ((wxSizerItem *) x));
47904 }
47905 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
47906 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
47907 }
47908 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
47909 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
47910 }
47911 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
47912 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
47913 }
47914 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
47915 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
47916 }
47917 static void *_p_wxSizerTo_p_wxObject(void *x) {
47918 return (void *)((wxObject *) ((wxSizer *) x));
47919 }
47920 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
47921 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47922 }
47923 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
47924 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
47925 }
47926 static void *_p_wxEventTo_p_wxObject(void *x) {
47927 return (void *)((wxObject *) ((wxEvent *) x));
47928 }
47929 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
47930 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
47931 }
47932 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
47933 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
47934 }
47935 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
47936 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
47937 }
47938 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
47939 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
47940 }
47941 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
47942 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
47943 }
47944 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
47945 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
47946 }
47947 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
47948 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
47949 }
47950 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
47951 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47952 }
47953 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
47954 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
47955 }
47956 static void *_p_wxControlTo_p_wxObject(void *x) {
47957 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
47958 }
47959 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
47960 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
47961 }
47962 static void *_p_wxFSFileTo_p_wxObject(void *x) {
47963 return (void *)((wxObject *) ((wxFSFile *) x));
47964 }
47965 static void *_p_wxPySizerTo_p_wxObject(void *x) {
47966 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
47967 }
47968 static void *_p_wxPyEventTo_p_wxObject(void *x) {
47969 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
47970 }
47971 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
47972 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
47973 }
47974 static void *_p_wxShowEventTo_p_wxObject(void *x) {
47975 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
47976 }
47977 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
47978 return (void *)((wxObject *) ((wxMenuItem *) x));
47979 }
47980 static void *_p_wxDateEventTo_p_wxObject(void *x) {
47981 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
47982 }
47983 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
47984 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
47985 }
47986 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
47987 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
47988 }
47989 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
47990 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
47991 }
47992 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
47993 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
47994 }
47995 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
47996 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
47997 }
47998 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
47999 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
48000 }
48001 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
48002 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
48003 }
48004 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
48005 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
48006 }
48007 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
48008 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
48009 }
48010 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
48011 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
48012 }
48013 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
48014 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
48015 }
48016 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
48017 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
48018 }
48019 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
48020 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
48021 }
48022 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
48023 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
48024 }
48025 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
48026 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
48027 }
48028 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
48029 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
48030 }
48031 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
48032 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
48033 }
48034 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
48035 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
48036 }
48037 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
48038 return (void *)((wxObject *) ((wxImageHandler *) x));
48039 }
48040 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
48041 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
48042 }
48043 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
48044 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
48045 }
48046 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
48047 return (void *)((wxObject *) ((wxEvtHandler *) x));
48048 }
48049 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
48050 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
48051 }
48052 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
48053 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
48054 }
48055 static void *_p_wxImageTo_p_wxObject(void *x) {
48056 return (void *)((wxObject *) ((wxImage *) x));
48057 }
48058 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
48059 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
48060 }
48061 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
48062 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
48063 }
48064 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
48065 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
48066 }
48067 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
48068 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
48069 }
48070 static void *_p_wxWindowTo_p_wxObject(void *x) {
48071 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
48072 }
48073 static void *_p_wxMenuTo_p_wxObject(void *x) {
48074 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
48075 }
48076 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
48077 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
48078 }
48079 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
48080 return (void *)((wxObject *) ((wxFileSystem *) x));
48081 }
48082 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
48083 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
48084 }
48085 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
48086 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
48087 }
48088 static void *_p_wxPyAppTo_p_wxObject(void *x) {
48089 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
48090 }
48091 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
48092 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
48093 }
48094 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
48095 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
48096 }
48097 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
48098 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
48099 }
48100 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
48101 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
48102 }
48103 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
48104 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
48105 }
48106 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
48107 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
48108 }
48109 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
48110 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
48111 }
48112 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
48113 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
48114 }
48115 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
48116 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
48117 }
48118 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
48119 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
48120 }
48121 static void *_p_wxValidatorTo_p_wxObject(void *x) {
48122 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
48123 }
48124 static void *_p_wxControlTo_p_wxWindow(void *x) {
48125 return (void *)((wxWindow *) ((wxControl *) x));
48126 }
48127 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
48128 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
48129 }
48130 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
48131 return (void *)((wxWindow *) ((wxMenuBar *) x));
48132 }
48133 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
48134 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
48135 }
48136 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
48137 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
48138 }
48139 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
48140 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
48141 }
48142 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
48143 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
48144 }
48145 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
48146 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
48147 }
48148 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
48149 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
48150 }
48151 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
48152 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
48153 }
48154 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
48155 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
48156 }
48157 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
48158 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
48159 }
48160 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
48161 return (void *)((wxValidator *) ((wxPyValidator *) x));
48162 }
48163 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, 0};
48164 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, 0};
48165 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, 0};
48166 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, 0};
48167 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, 0};
48168 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, 0};
48169 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, 0};
48170 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, 0};
48171 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, 0};
48172 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, 0};
48173 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, 0};
48174 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, 0};
48175 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, 0};
48176 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, 0};
48177 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, 0};
48178 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, 0};
48179 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, 0};
48180 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, 0};
48181 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, 0};
48182 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, 0};
48183 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, 0};
48184 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, 0};
48185 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, 0};
48186 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, 0};
48187 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, 0};
48188 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, 0};
48189 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, 0};
48190 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, 0};
48191 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, 0};
48192 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, 0};
48193 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, 0};
48194 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, 0};
48195 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, 0};
48196 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0};
48197 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, 0};
48198 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, 0};
48199 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, 0};
48200 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, 0};
48201 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, 0};
48202 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, 0};
48203 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, 0};
48204 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, 0};
48205 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, 0};
48206 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, 0};
48207 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, 0};
48208 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, 0};
48209 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, 0};
48210 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, 0};
48211 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, 0};
48212 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, 0};
48213 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, 0};
48214 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, 0};
48215 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, 0};
48216 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, 0};
48217 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, 0};
48218 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, 0};
48219 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, 0};
48220 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, 0};
48221 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, 0};
48222 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, 0};
48223 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, 0};
48224 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, 0};
48225 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, 0};
48226 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, 0};
48227 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, 0};
48228 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, 0};
48229 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, 0};
48230 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, 0};
48231 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, 0};
48232 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, 0};
48233 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, 0};
48234 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, 0};
48235 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, 0};
48236 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, 0};
48237 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, 0};
48238 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, 0};
48239 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, 0};
48240 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, 0};
48241 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, 0};
48242 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, 0};
48243 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, 0};
48244 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, 0};
48245 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, 0};
48246 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, 0};
48247 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, 0};
48248 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, 0};
48249 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, 0};
48250 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, 0};
48251 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, 0};
48252 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, 0};
48253 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, 0};
48254 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, 0};
48255 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, 0};
48256 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, 0};
48257 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, 0};
48258 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, 0};
48259 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, 0};
48260 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, 0};
48261 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, 0};
48262 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, 0};
48263 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, 0};
48264 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, 0};
48265 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, 0};
48266 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, 0};
48267 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, 0};
48268 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, 0};
48269 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, 0};
48270 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, 0};
48271 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, 0};
48272 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, 0};
48273 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, 0};
48274 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, 0};
48275 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, 0};
48276 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, 0};
48277 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, 0};
48278 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, 0};
48279 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, 0};
48280 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, 0};
48281 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, 0};
48282 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, 0};
48283 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, 0};
48284 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, 0};
48285 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, 0};
48286 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, 0};
48287 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, 0};
48288 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, 0};
48289 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, 0};
48290 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, 0};
48291 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, 0};
48292 static swig_type_info _swigt__ptrdiff_t = {"_ptrdiff_t", "ptrdiff_t", 0, 0, 0};
48293 static swig_type_info _swigt__std__ptrdiff_t = {"_std__ptrdiff_t", "std::ptrdiff_t", 0, 0, 0};
48294 static swig_type_info _swigt__unsigned_int = {"_unsigned_int", "unsigned int|std::size_t", 0, 0, 0};
48295
48296 static swig_type_info *swig_type_initial[] = {
48297 &_swigt__p_buffer,
48298 &_swigt__p_char,
48299 &_swigt__p_form_ops_t,
48300 &_swigt__p_int,
48301 &_swigt__p_long,
48302 &_swigt__p_unsigned_char,
48303 &_swigt__p_unsigned_int,
48304 &_swigt__p_unsigned_long,
48305 &_swigt__p_wxANIHandler,
48306 &_swigt__p_wxAcceleratorEntry,
48307 &_swigt__p_wxAcceleratorTable,
48308 &_swigt__p_wxActivateEvent,
48309 &_swigt__p_wxAppTraits,
48310 &_swigt__p_wxArrayString,
48311 &_swigt__p_wxBMPHandler,
48312 &_swigt__p_wxBitmap,
48313 &_swigt__p_wxBoxSizer,
48314 &_swigt__p_wxButton,
48315 &_swigt__p_wxCURHandler,
48316 &_swigt__p_wxCaret,
48317 &_swigt__p_wxChildFocusEvent,
48318 &_swigt__p_wxCloseEvent,
48319 &_swigt__p_wxColour,
48320 &_swigt__p_wxCommandEvent,
48321 &_swigt__p_wxContextMenuEvent,
48322 &_swigt__p_wxControl,
48323 &_swigt__p_wxControlWithItems,
48324 &_swigt__p_wxCursor,
48325 &_swigt__p_wxDC,
48326 &_swigt__p_wxDateEvent,
48327 &_swigt__p_wxDateTime,
48328 &_swigt__p_wxDisplayChangedEvent,
48329 &_swigt__p_wxDropFilesEvent,
48330 &_swigt__p_wxDuplexMode,
48331 &_swigt__p_wxEraseEvent,
48332 &_swigt__p_wxEvent,
48333 &_swigt__p_wxEventLoop,
48334 &_swigt__p_wxEventLoopActivator,
48335 &_swigt__p_wxEvtHandler,
48336 &_swigt__p_wxFSFile,
48337 &_swigt__p_wxFileSystem,
48338 &_swigt__p_wxFileSystemHandler,
48339 &_swigt__p_wxFlexGridSizer,
48340 &_swigt__p_wxFocusEvent,
48341 &_swigt__p_wxFont,
48342 &_swigt__p_wxFrame,
48343 &_swigt__p_wxGBPosition,
48344 &_swigt__p_wxGBSizerItem,
48345 &_swigt__p_wxGBSpan,
48346 &_swigt__p_wxGIFHandler,
48347 &_swigt__p_wxGridBagSizer,
48348 &_swigt__p_wxGridSizer,
48349 &_swigt__p_wxICOHandler,
48350 &_swigt__p_wxIconizeEvent,
48351 &_swigt__p_wxIdleEvent,
48352 &_swigt__p_wxImage,
48353 &_swigt__p_wxImageHandler,
48354 &_swigt__p_wxImageHistogram,
48355 &_swigt__p_wxImage_HSVValue,
48356 &_swigt__p_wxImage_RGBValue,
48357 &_swigt__p_wxIndividualLayoutConstraint,
48358 &_swigt__p_wxInitDialogEvent,
48359 &_swigt__p_wxInputStream,
48360 &_swigt__p_wxInternetFSHandler,
48361 &_swigt__p_wxItemContainer,
48362 &_swigt__p_wxJPEGHandler,
48363 &_swigt__p_wxKeyEvent,
48364 &_swigt__p_wxLayoutConstraints,
48365 &_swigt__p_wxMaximizeEvent,
48366 &_swigt__p_wxMemoryFSHandler,
48367 &_swigt__p_wxMenu,
48368 &_swigt__p_wxMenuBar,
48369 &_swigt__p_wxMenuBarBase,
48370 &_swigt__p_wxMenuEvent,
48371 &_swigt__p_wxMenuItem,
48372 &_swigt__p_wxMouseCaptureChangedEvent,
48373 &_swigt__p_wxMouseEvent,
48374 &_swigt__p_wxMoveEvent,
48375 &_swigt__p_wxNavigationKeyEvent,
48376 &_swigt__p_wxNcPaintEvent,
48377 &_swigt__p_wxNotifyEvent,
48378 &_swigt__p_wxObject,
48379 &_swigt__p_wxOutputStream,
48380 &_swigt__p_wxPCXHandler,
48381 &_swigt__p_wxPNGHandler,
48382 &_swigt__p_wxPNMHandler,
48383 &_swigt__p_wxPaintEvent,
48384 &_swigt__p_wxPaletteChangedEvent,
48385 &_swigt__p_wxPaperSize,
48386 &_swigt__p_wxPoint,
48387 &_swigt__p_wxPoint2D,
48388 &_swigt__p_wxPropagateOnce,
48389 &_swigt__p_wxPropagationDisabler,
48390 &_swigt__p_wxPyApp,
48391 &_swigt__p_wxPyCommandEvent,
48392 &_swigt__p_wxPyDropTarget,
48393 &_swigt__p_wxPyEvent,
48394 &_swigt__p_wxPyFileSystemHandler,
48395 &_swigt__p_wxPyImageHandler,
48396 &_swigt__p_wxPyInputStream,
48397 &_swigt__p_wxPySizer,
48398 &_swigt__p_wxPyValidator,
48399 &_swigt__p_wxQuantize,
48400 &_swigt__p_wxQueryNewPaletteEvent,
48401 &_swigt__p_wxRealPoint,
48402 &_swigt__p_wxRect,
48403 &_swigt__p_wxRegion,
48404 &_swigt__p_wxScrollEvent,
48405 &_swigt__p_wxScrollWinEvent,
48406 &_swigt__p_wxSetCursorEvent,
48407 &_swigt__p_wxShowEvent,
48408 &_swigt__p_wxSize,
48409 &_swigt__p_wxSizeEvent,
48410 &_swigt__p_wxSizer,
48411 &_swigt__p_wxSizerItem,
48412 &_swigt__p_wxStaticBox,
48413 &_swigt__p_wxStaticBoxSizer,
48414 &_swigt__p_wxStdDialogButtonSizer,
48415 &_swigt__p_wxSysColourChangedEvent,
48416 &_swigt__p_wxTIFFHandler,
48417 &_swigt__p_wxToolTip,
48418 &_swigt__p_wxUpdateUIEvent,
48419 &_swigt__p_wxValidator,
48420 &_swigt__p_wxVisualAttributes,
48421 &_swigt__p_wxWindow,
48422 &_swigt__p_wxWindowCreateEvent,
48423 &_swigt__p_wxWindowDestroyEvent,
48424 &_swigt__p_wxXPMHandler,
48425 &_swigt__p_wxZipFSHandler,
48426 &_swigt__ptrdiff_t,
48427 &_swigt__std__ptrdiff_t,
48428 &_swigt__unsigned_int,
48429 };
48430
48431 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
48432 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
48433 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
48434 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
48435 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
48436 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
48437 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
48438 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
48439 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
48440 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
48441 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
48442 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
48443 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
48444 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
48445 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}};
48446 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
48447 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}};
48448 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
48449 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}};
48450 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
48451 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
48452 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
48453 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
48454 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}};
48455 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
48456 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}};
48457 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
48458 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
48459 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
48460 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
48461 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
48462 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48463 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
48464 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
48465 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
48466 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}};
48467 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
48468 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
48469 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}};
48470 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
48471 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
48472 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}};
48473 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}};
48474 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
48475 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
48476 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
48477 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
48478 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
48479 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
48480 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
48481 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
48482 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}};
48483 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}};
48484 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48485 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
48486 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
48487 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}};
48488 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
48489 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
48490 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
48491 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
48492 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
48493 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
48494 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48495 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}};
48496 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
48497 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
48498 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
48499 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48500 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48501 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
48502 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
48503 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
48504 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
48505 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
48506 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48507 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
48508 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
48509 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
48510 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
48511 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
48512 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}};
48513 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
48514 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
48515 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
48516 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
48517 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
48518 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48519 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
48520 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
48521 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
48522 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
48523 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
48524 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
48525 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
48526 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
48527 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
48528 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
48529 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
48530 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
48531 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
48532 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
48533 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
48534 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
48535 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
48536 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
48537 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
48538 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
48539 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
48540 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
48541 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
48542 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
48543 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48544 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}};
48545 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}};
48546 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
48547 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
48548 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
48549 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48550 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
48551 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
48552 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
48553 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}};
48554 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
48555 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}};
48556 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
48557 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
48558 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
48559 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48560 static swig_cast_info _swigc__ptrdiff_t[] = { {&_swigt__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
48561 static swig_cast_info _swigc__std__ptrdiff_t[] = { {&_swigt__std__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
48562 static swig_cast_info _swigc__unsigned_int[] = { {&_swigt__unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
48563
48564 static swig_cast_info *swig_cast_initial[] = {
48565 _swigc__p_buffer,
48566 _swigc__p_char,
48567 _swigc__p_form_ops_t,
48568 _swigc__p_int,
48569 _swigc__p_long,
48570 _swigc__p_unsigned_char,
48571 _swigc__p_unsigned_int,
48572 _swigc__p_unsigned_long,
48573 _swigc__p_wxANIHandler,
48574 _swigc__p_wxAcceleratorEntry,
48575 _swigc__p_wxAcceleratorTable,
48576 _swigc__p_wxActivateEvent,
48577 _swigc__p_wxAppTraits,
48578 _swigc__p_wxArrayString,
48579 _swigc__p_wxBMPHandler,
48580 _swigc__p_wxBitmap,
48581 _swigc__p_wxBoxSizer,
48582 _swigc__p_wxButton,
48583 _swigc__p_wxCURHandler,
48584 _swigc__p_wxCaret,
48585 _swigc__p_wxChildFocusEvent,
48586 _swigc__p_wxCloseEvent,
48587 _swigc__p_wxColour,
48588 _swigc__p_wxCommandEvent,
48589 _swigc__p_wxContextMenuEvent,
48590 _swigc__p_wxControl,
48591 _swigc__p_wxControlWithItems,
48592 _swigc__p_wxCursor,
48593 _swigc__p_wxDC,
48594 _swigc__p_wxDateEvent,
48595 _swigc__p_wxDateTime,
48596 _swigc__p_wxDisplayChangedEvent,
48597 _swigc__p_wxDropFilesEvent,
48598 _swigc__p_wxDuplexMode,
48599 _swigc__p_wxEraseEvent,
48600 _swigc__p_wxEvent,
48601 _swigc__p_wxEventLoop,
48602 _swigc__p_wxEventLoopActivator,
48603 _swigc__p_wxEvtHandler,
48604 _swigc__p_wxFSFile,
48605 _swigc__p_wxFileSystem,
48606 _swigc__p_wxFileSystemHandler,
48607 _swigc__p_wxFlexGridSizer,
48608 _swigc__p_wxFocusEvent,
48609 _swigc__p_wxFont,
48610 _swigc__p_wxFrame,
48611 _swigc__p_wxGBPosition,
48612 _swigc__p_wxGBSizerItem,
48613 _swigc__p_wxGBSpan,
48614 _swigc__p_wxGIFHandler,
48615 _swigc__p_wxGridBagSizer,
48616 _swigc__p_wxGridSizer,
48617 _swigc__p_wxICOHandler,
48618 _swigc__p_wxIconizeEvent,
48619 _swigc__p_wxIdleEvent,
48620 _swigc__p_wxImage,
48621 _swigc__p_wxImageHandler,
48622 _swigc__p_wxImageHistogram,
48623 _swigc__p_wxImage_HSVValue,
48624 _swigc__p_wxImage_RGBValue,
48625 _swigc__p_wxIndividualLayoutConstraint,
48626 _swigc__p_wxInitDialogEvent,
48627 _swigc__p_wxInputStream,
48628 _swigc__p_wxInternetFSHandler,
48629 _swigc__p_wxItemContainer,
48630 _swigc__p_wxJPEGHandler,
48631 _swigc__p_wxKeyEvent,
48632 _swigc__p_wxLayoutConstraints,
48633 _swigc__p_wxMaximizeEvent,
48634 _swigc__p_wxMemoryFSHandler,
48635 _swigc__p_wxMenu,
48636 _swigc__p_wxMenuBar,
48637 _swigc__p_wxMenuBarBase,
48638 _swigc__p_wxMenuEvent,
48639 _swigc__p_wxMenuItem,
48640 _swigc__p_wxMouseCaptureChangedEvent,
48641 _swigc__p_wxMouseEvent,
48642 _swigc__p_wxMoveEvent,
48643 _swigc__p_wxNavigationKeyEvent,
48644 _swigc__p_wxNcPaintEvent,
48645 _swigc__p_wxNotifyEvent,
48646 _swigc__p_wxObject,
48647 _swigc__p_wxOutputStream,
48648 _swigc__p_wxPCXHandler,
48649 _swigc__p_wxPNGHandler,
48650 _swigc__p_wxPNMHandler,
48651 _swigc__p_wxPaintEvent,
48652 _swigc__p_wxPaletteChangedEvent,
48653 _swigc__p_wxPaperSize,
48654 _swigc__p_wxPoint,
48655 _swigc__p_wxPoint2D,
48656 _swigc__p_wxPropagateOnce,
48657 _swigc__p_wxPropagationDisabler,
48658 _swigc__p_wxPyApp,
48659 _swigc__p_wxPyCommandEvent,
48660 _swigc__p_wxPyDropTarget,
48661 _swigc__p_wxPyEvent,
48662 _swigc__p_wxPyFileSystemHandler,
48663 _swigc__p_wxPyImageHandler,
48664 _swigc__p_wxPyInputStream,
48665 _swigc__p_wxPySizer,
48666 _swigc__p_wxPyValidator,
48667 _swigc__p_wxQuantize,
48668 _swigc__p_wxQueryNewPaletteEvent,
48669 _swigc__p_wxRealPoint,
48670 _swigc__p_wxRect,
48671 _swigc__p_wxRegion,
48672 _swigc__p_wxScrollEvent,
48673 _swigc__p_wxScrollWinEvent,
48674 _swigc__p_wxSetCursorEvent,
48675 _swigc__p_wxShowEvent,
48676 _swigc__p_wxSize,
48677 _swigc__p_wxSizeEvent,
48678 _swigc__p_wxSizer,
48679 _swigc__p_wxSizerItem,
48680 _swigc__p_wxStaticBox,
48681 _swigc__p_wxStaticBoxSizer,
48682 _swigc__p_wxStdDialogButtonSizer,
48683 _swigc__p_wxSysColourChangedEvent,
48684 _swigc__p_wxTIFFHandler,
48685 _swigc__p_wxToolTip,
48686 _swigc__p_wxUpdateUIEvent,
48687 _swigc__p_wxValidator,
48688 _swigc__p_wxVisualAttributes,
48689 _swigc__p_wxWindow,
48690 _swigc__p_wxWindowCreateEvent,
48691 _swigc__p_wxWindowDestroyEvent,
48692 _swigc__p_wxXPMHandler,
48693 _swigc__p_wxZipFSHandler,
48694 _swigc__ptrdiff_t,
48695 _swigc__std__ptrdiff_t,
48696 _swigc__unsigned_int,
48697 };
48698
48699
48700 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
48701
48702 static swig_const_info swig_const_table[] = {
48703 {0, 0, 0, 0.0, 0, 0}};
48704
48705 #ifdef __cplusplus
48706 }
48707 #endif
48708 /*************************************************************************
48709 * Type initialization:
48710 * This problem is tough by the requirement that no dynamic
48711 * memory is used. Also, since swig_type_info structures store pointers to
48712 * swig_cast_info structures and swig_cast_info structures store pointers back
48713 * to swig_type_info structures, we need some lookup code at initialization.
48714 * The idea is that swig generates all the structures that are needed.
48715 * The runtime then collects these partially filled structures.
48716 * The SWIG_InitializeModule function takes these initial arrays out of
48717 * swig_module, and does all the lookup, filling in the swig_module.types
48718 * array with the correct data and linking the correct swig_cast_info
48719 * structures together.
48720
48721 * The generated swig_type_info structures are assigned staticly to an initial
48722 * array. We just loop though that array, and handle each type individually.
48723 * First we lookup if this type has been already loaded, and if so, use the
48724 * loaded structure instead of the generated one. Then we have to fill in the
48725 * cast linked list. The cast data is initially stored in something like a
48726 * two-dimensional array. Each row corresponds to a type (there are the same
48727 * number of rows as there are in the swig_type_initial array). Each entry in
48728 * a column is one of the swig_cast_info structures for that type.
48729 * The cast_initial array is actually an array of arrays, because each row has
48730 * a variable number of columns. So to actually build the cast linked list,
48731 * we find the array of casts associated with the type, and loop through it
48732 * adding the casts to the list. The one last trick we need to do is making
48733 * sure the type pointer in the swig_cast_info struct is correct.
48734
48735 * First off, we lookup the cast->type name to see if it is already loaded.
48736 * There are three cases to handle:
48737 * 1) If the cast->type has already been loaded AND the type we are adding
48738 * casting info to has not been loaded (it is in this module), THEN we
48739 * replace the cast->type pointer with the type pointer that has already
48740 * been loaded.
48741 * 2) If BOTH types (the one we are adding casting info to, and the
48742 * cast->type) are loaded, THEN the cast info has already been loaded by
48743 * the previous module so we just ignore it.
48744 * 3) Finally, if cast->type has not already been loaded, then we add that
48745 * swig_cast_info to the linked list (because the cast->type) pointer will
48746 * be correct.
48747 **/
48748
48749 #ifdef __cplusplus
48750 extern "C" {
48751 #if 0
48752 } /* c-mode */
48753 #endif
48754 #endif
48755
48756 #if 0
48757 #define SWIGRUNTIME_DEBUG
48758 #endif
48759
48760 SWIGRUNTIME void
48761 SWIG_InitializeModule(void *clientdata) {
48762 size_t i;
48763 swig_module_info *module_head;
48764 static int init_run = 0;
48765
48766 clientdata = clientdata;
48767
48768 if (init_run) return;
48769 init_run = 1;
48770
48771 /* Initialize the swig_module */
48772 swig_module.type_initial = swig_type_initial;
48773 swig_module.cast_initial = swig_cast_initial;
48774
48775 /* Try and load any already created modules */
48776 module_head = SWIG_GetModule(clientdata);
48777 if (module_head) {
48778 swig_module.next = module_head->next;
48779 module_head->next = &swig_module;
48780 } else {
48781 /* This is the first module loaded */
48782 swig_module.next = &swig_module;
48783 SWIG_SetModule(clientdata, &swig_module);
48784 }
48785
48786 /* Now work on filling in swig_module.types */
48787 #ifdef SWIGRUNTIME_DEBUG
48788 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
48789 #endif
48790 for (i = 0; i < swig_module.size; ++i) {
48791 swig_type_info *type = 0;
48792 swig_type_info *ret;
48793 swig_cast_info *cast;
48794
48795 #ifdef SWIGRUNTIME_DEBUG
48796 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
48797 #endif
48798
48799 /* if there is another module already loaded */
48800 if (swig_module.next != &swig_module) {
48801 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
48802 }
48803 if (type) {
48804 /* Overwrite clientdata field */
48805 #ifdef SWIGRUNTIME_DEBUG
48806 printf("SWIG_InitializeModule: found type %s\n", type->name);
48807 #endif
48808 if (swig_module.type_initial[i]->clientdata) {
48809 type->clientdata = swig_module.type_initial[i]->clientdata;
48810 #ifdef SWIGRUNTIME_DEBUG
48811 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
48812 #endif
48813 }
48814 } else {
48815 type = swig_module.type_initial[i];
48816 }
48817
48818 /* Insert casting types */
48819 cast = swig_module.cast_initial[i];
48820 while (cast->type) {
48821 /* Don't need to add information already in the list */
48822 ret = 0;
48823 #ifdef SWIGRUNTIME_DEBUG
48824 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
48825 #endif
48826 if (swig_module.next != &swig_module) {
48827 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
48828 #ifdef SWIGRUNTIME_DEBUG
48829 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
48830 #endif
48831 }
48832 if (ret) {
48833 if (type == swig_module.type_initial[i]) {
48834 #ifdef SWIGRUNTIME_DEBUG
48835 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
48836 #endif
48837 cast->type = ret;
48838 ret = 0;
48839 } else {
48840 /* Check for casting already in the list */
48841 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
48842 #ifdef SWIGRUNTIME_DEBUG
48843 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
48844 #endif
48845 if (!ocast) ret = 0;
48846 }
48847 }
48848
48849 if (!ret) {
48850 #ifdef SWIGRUNTIME_DEBUG
48851 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
48852 #endif
48853 if (type->cast) {
48854 type->cast->prev = cast;
48855 cast->next = type->cast;
48856 }
48857 type->cast = cast;
48858 }
48859 cast++;
48860 }
48861 /* Set entry in modules->types array equal to the type */
48862 swig_module.types[i] = type;
48863 }
48864 swig_module.types[i] = 0;
48865
48866 #ifdef SWIGRUNTIME_DEBUG
48867 printf("**** SWIG_InitializeModule: Cast List ******\n");
48868 for (i = 0; i < swig_module.size; ++i) {
48869 int j = 0;
48870 swig_cast_info *cast = swig_module.cast_initial[i];
48871 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
48872 while (cast->type) {
48873 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
48874 cast++;
48875 ++j;
48876 }
48877 printf("---- Total casts: %d\n",j);
48878 }
48879 printf("**** SWIG_InitializeModule: Cast List ******\n");
48880 #endif
48881 }
48882
48883 /* This function will propagate the clientdata field of type to
48884 * any new swig_type_info structures that have been added into the list
48885 * of equivalent types. It is like calling
48886 * SWIG_TypeClientData(type, clientdata) a second time.
48887 */
48888 SWIGRUNTIME void
48889 SWIG_PropagateClientData(void) {
48890 size_t i;
48891 swig_cast_info *equiv;
48892 static int init_run = 0;
48893
48894 if (init_run) return;
48895 init_run = 1;
48896
48897 for (i = 0; i < swig_module.size; i++) {
48898 if (swig_module.types[i]->clientdata) {
48899 equiv = swig_module.types[i]->cast;
48900 while (equiv) {
48901 if (!equiv->converter) {
48902 if (equiv->type && !equiv->type->clientdata)
48903 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
48904 }
48905 equiv = equiv->next;
48906 }
48907 }
48908 }
48909 }
48910
48911 #ifdef __cplusplus
48912 #if 0
48913 {
48914 /* c-mode */
48915 #endif
48916 }
48917 #endif
48918
48919
48920
48921 #ifdef __cplusplus
48922 extern "C" {
48923 #endif
48924
48925 /* Python-specific SWIG API */
48926 #define SWIG_newvarlink() SWIG_Python_newvarlink()
48927 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
48928 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
48929
48930 /* -----------------------------------------------------------------------------
48931 * global variable support code.
48932 * ----------------------------------------------------------------------------- */
48933
48934 typedef struct swig_globalvar {
48935 char *name; /* Name of global variable */
48936 PyObject *(*get_attr)(void); /* Return the current value */
48937 int (*set_attr)(PyObject *); /* Set the value */
48938 struct swig_globalvar *next;
48939 } swig_globalvar;
48940
48941 typedef struct swig_varlinkobject {
48942 PyObject_HEAD
48943 swig_globalvar *vars;
48944 } swig_varlinkobject;
48945
48946 SWIGINTERN PyObject *
48947 swig_varlink_repr(swig_varlinkobject *v) {
48948 v = v;
48949 return PyString_FromString("<Swig global variables>");
48950 }
48951
48952 SWIGINTERN int
48953 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
48954 swig_globalvar *var;
48955 flags = flags;
48956 fprintf(fp,"Swig global variables { ");
48957 for (var = v->vars; var; var=var->next) {
48958 fprintf(fp,"%s", var->name);
48959 if (var->next) fprintf(fp,", ");
48960 }
48961 fprintf(fp," }\n");
48962 return 0;
48963 }
48964
48965 SWIGINTERN PyObject *
48966 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
48967 swig_globalvar *var = v->vars;
48968 while (var) {
48969 if (strcmp(var->name,n) == 0) {
48970 return (*var->get_attr)();
48971 }
48972 var = var->next;
48973 }
48974 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48975 return NULL;
48976 }
48977
48978 SWIGINTERN int
48979 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
48980 swig_globalvar *var = v->vars;
48981 while (var) {
48982 if (strcmp(var->name,n) == 0) {
48983 return (*var->set_attr)(p);
48984 }
48985 var = var->next;
48986 }
48987 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48988 return 1;
48989 }
48990
48991 SWIGINTERN PyTypeObject*
48992 swig_varlink_type(void) {
48993 static char varlink__doc__[] = "Swig var link object";
48994 static PyTypeObject varlink_type
48995 #if !defined(__cplusplus)
48996 ;
48997 static int type_init = 0;
48998 if (!type_init) {
48999 PyTypeObject tmp
49000 #endif
49001 = {
49002 PyObject_HEAD_INIT(&PyType_Type)
49003 0, /* Number of items in variable part (ob_size) */
49004 (char *)"swigvarlink", /* Type name (tp_name) */
49005 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
49006 0, /* Itemsize (tp_itemsize) */
49007 0, /* Deallocator (tp_dealloc) */
49008 (printfunc) swig_varlink_print, /* Print (tp_print) */
49009 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
49010 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
49011 0, /* tp_compare */
49012 (reprfunc) swig_varlink_repr, /* tp_repr */
49013 0, /* tp_as_number */
49014 0, /* tp_as_sequence */
49015 0, /* tp_as_mapping */
49016 0, /* tp_hash */
49017 0, /* tp_call */
49018 0, /* tp_str */
49019 0, /* tp_getattro */
49020 0, /* tp_setattro */
49021 0, /* tp_as_buffer */
49022 0, /* tp_flags */
49023 varlink__doc__, /* tp_doc */
49024 #if PY_VERSION_HEX >= 0x02000000
49025 0, /* tp_traverse */
49026 0, /* tp_clear */
49027 #endif
49028 #if PY_VERSION_HEX >= 0x02010000
49029 0, /* tp_richcompare */
49030 0, /* tp_weaklistoffset */
49031 #endif
49032 #if PY_VERSION_HEX >= 0x02020000
49033 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
49034 #endif
49035 #if PY_VERSION_HEX >= 0x02030000
49036 0, /* tp_del */
49037 #endif
49038 #ifdef COUNT_ALLOCS
49039 0,0,0,0 /* tp_alloc -> tp_next */
49040 #endif
49041 };
49042 #if !defined(__cplusplus)
49043 varlink_type = tmp;
49044 type_init = 1;
49045 }
49046 #endif
49047 return &varlink_type;
49048 }
49049
49050 /* Create a variable linking object for use later */
49051 SWIGINTERN PyObject *
49052 SWIG_Python_newvarlink(void) {
49053 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
49054 if (result) {
49055 result->vars = 0;
49056 }
49057 return ((PyObject*) result);
49058 }
49059
49060 SWIGINTERN void
49061 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
49062 swig_varlinkobject *v = (swig_varlinkobject *) p;
49063 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
49064 if (gv) {
49065 size_t size = strlen(name)+1;
49066 gv->name = (char *)malloc(size);
49067 if (gv->name) {
49068 strncpy(gv->name,name,size);
49069 gv->get_attr = get_attr;
49070 gv->set_attr = set_attr;
49071 gv->next = v->vars;
49072 }
49073 }
49074 v->vars = gv;
49075 }
49076
49077 /* -----------------------------------------------------------------------------
49078 * constants/methods manipulation
49079 * ----------------------------------------------------------------------------- */
49080
49081 /* Install Constants */
49082 SWIGINTERN void
49083 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
49084 PyObject *obj = 0;
49085 size_t i;
49086 for (i = 0; constants[i].type; ++i) {
49087 switch(constants[i].type) {
49088 case SWIG_PY_INT:
49089 obj = PyInt_FromLong(constants[i].lvalue);
49090 break;
49091 case SWIG_PY_FLOAT:
49092 obj = PyFloat_FromDouble(constants[i].dvalue);
49093 break;
49094 case SWIG_PY_STRING:
49095 if (constants[i].pvalue) {
49096 obj = PyString_FromString((char *) constants[i].pvalue);
49097 } else {
49098 Py_INCREF(Py_None);
49099 obj = Py_None;
49100 }
49101 break;
49102 case SWIG_PY_POINTER:
49103 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
49104 break;
49105 case SWIG_PY_BINARY:
49106 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
49107 break;
49108 default:
49109 obj = 0;
49110 break;
49111 }
49112 if (obj) {
49113 PyDict_SetItemString(d,constants[i].name,obj);
49114 Py_DECREF(obj);
49115 }
49116 }
49117 }
49118
49119 /* -----------------------------------------------------------------------------*/
49120 /* Fix SwigMethods to carry the callback ptrs when needed */
49121 /* -----------------------------------------------------------------------------*/
49122
49123 SWIGINTERN void
49124 SWIG_Python_FixMethods(PyMethodDef *methods,
49125 swig_const_info *const_table,
49126 swig_type_info **types,
49127 swig_type_info **types_initial) {
49128 size_t i;
49129 for (i = 0; methods[i].ml_name; ++i) {
49130 char *c = methods[i].ml_doc;
49131 if (c && (c = strstr(c, "swig_ptr: "))) {
49132 int j;
49133 swig_const_info *ci = 0;
49134 char *name = c + 10;
49135 for (j = 0; const_table[j].type; ++j) {
49136 if (strncmp(const_table[j].name, name,
49137 strlen(const_table[j].name)) == 0) {
49138 ci = &(const_table[j]);
49139 break;
49140 }
49141 }
49142 if (ci) {
49143 size_t shift = (ci->ptype) - types;
49144 swig_type_info *ty = types_initial[shift];
49145 size_t ldoc = (c - methods[i].ml_doc);
49146 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
49147 char *ndoc = (char*)malloc(ldoc + lptr + 10);
49148 if (ndoc) {
49149 char *buff = ndoc;
49150 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
49151 if (ptr) {
49152 strncpy(buff, methods[i].ml_doc, ldoc);
49153 buff += ldoc;
49154 strncpy(buff, "swig_ptr: ", 10);
49155 buff += 10;
49156 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
49157 methods[i].ml_doc = ndoc;
49158 }
49159 }
49160 }
49161 }
49162 }
49163 }
49164
49165 /* -----------------------------------------------------------------------------*
49166 * Initialize type list
49167 * -----------------------------------------------------------------------------*/
49168
49169 #ifdef __cplusplus
49170 }
49171 #endif
49172
49173 /* -----------------------------------------------------------------------------*
49174 * Partial Init method
49175 * -----------------------------------------------------------------------------*/
49176
49177 #ifdef __cplusplus
49178 extern "C"
49179 #endif
49180 SWIGEXPORT void SWIG_init(void) {
49181 static PyObject *SWIG_globals = 0;
49182 PyObject *m, *d;
49183 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
49184
49185 /* Fix SwigMethods to carry the callback ptrs when needed */
49186 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
49187
49188 m = Py_InitModule((char *) SWIG_name, SwigMethods);
49189 d = PyModule_GetDict(m);
49190
49191 SWIG_InitializeModule(0);
49192 SWIG_InstallConstants(d,swig_const_table);
49193
49194
49195 #ifndef wxPyUSE_EXPORT
49196 // Make our API structure a CObject so other modules can import it
49197 // from this module.
49198 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
49199 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
49200 Py_XDECREF(cobj);
49201 #endif
49202
49203 {
49204 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int(static_cast<int >(wxNOT_FOUND)));
49205 }
49206 {
49207 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int(static_cast<int >(wxVSCROLL)));
49208 }
49209 {
49210 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int(static_cast<int >(wxHSCROLL)));
49211 }
49212 {
49213 PyDict_SetItemString(d,"CAPTION", SWIG_From_int(static_cast<int >(wxCAPTION)));
49214 }
49215 {
49216 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int(static_cast<int >(wxDOUBLE_BORDER)));
49217 }
49218 {
49219 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int(static_cast<int >(wxSUNKEN_BORDER)));
49220 }
49221 {
49222 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int(static_cast<int >(wxRAISED_BORDER)));
49223 }
49224 {
49225 PyDict_SetItemString(d,"BORDER", SWIG_From_int(static_cast<int >(wxBORDER)));
49226 }
49227 {
49228 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int(static_cast<int >(wxSIMPLE_BORDER)));
49229 }
49230 {
49231 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int(static_cast<int >(wxSTATIC_BORDER)));
49232 }
49233 {
49234 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int(static_cast<int >(wxTRANSPARENT_WINDOW)));
49235 }
49236 {
49237 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int(static_cast<int >(wxNO_BORDER)));
49238 }
49239 {
49240 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int(static_cast<int >(wxDEFAULT_CONTROL_BORDER)));
49241 }
49242 {
49243 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int(static_cast<int >(wxDEFAULT_STATUSBAR_STYLE)));
49244 }
49245 {
49246 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int(static_cast<int >(wxTAB_TRAVERSAL)));
49247 }
49248 {
49249 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int(static_cast<int >(wxWANTS_CHARS)));
49250 }
49251 {
49252 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int(static_cast<int >(wxPOPUP_WINDOW)));
49253 }
49254 {
49255 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int(static_cast<int >(wxCENTER_FRAME)));
49256 }
49257 {
49258 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int(static_cast<int >(wxCENTRE_ON_SCREEN)));
49259 }
49260 {
49261 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int(static_cast<int >(wxCENTER_ON_SCREEN)));
49262 }
49263 {
49264 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int(static_cast<int >(wxCLIP_CHILDREN)));
49265 }
49266 {
49267 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int(static_cast<int >(wxCLIP_SIBLINGS)));
49268 }
49269 {
49270 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int(static_cast<int >(wxALWAYS_SHOW_SB)));
49271 }
49272 {
49273 PyDict_SetItemString(d,"RETAINED", SWIG_From_int(static_cast<int >(wxRETAINED)));
49274 }
49275 {
49276 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int(static_cast<int >(wxBACKINGSTORE)));
49277 }
49278 {
49279 PyDict_SetItemString(d,"COLOURED", SWIG_From_int(static_cast<int >(wxCOLOURED)));
49280 }
49281 {
49282 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int(static_cast<int >(wxFIXED_LENGTH)));
49283 }
49284 {
49285 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int(static_cast<int >(wxLB_NEEDED_SB)));
49286 }
49287 {
49288 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int(static_cast<int >(wxLB_ALWAYS_SB)));
49289 }
49290 {
49291 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int(static_cast<int >(wxLB_SORT)));
49292 }
49293 {
49294 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int(static_cast<int >(wxLB_SINGLE)));
49295 }
49296 {
49297 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int(static_cast<int >(wxLB_MULTIPLE)));
49298 }
49299 {
49300 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int(static_cast<int >(wxLB_EXTENDED)));
49301 }
49302 {
49303 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int(static_cast<int >(wxLB_OWNERDRAW)));
49304 }
49305 {
49306 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int(static_cast<int >(wxLB_HSCROLL)));
49307 }
49308 {
49309 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int(static_cast<int >(wxPROCESS_ENTER)));
49310 }
49311 {
49312 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int(static_cast<int >(wxPASSWORD)));
49313 }
49314 {
49315 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int(static_cast<int >(wxCB_SIMPLE)));
49316 }
49317 {
49318 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int(static_cast<int >(wxCB_DROPDOWN)));
49319 }
49320 {
49321 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int(static_cast<int >(wxCB_SORT)));
49322 }
49323 {
49324 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int(static_cast<int >(wxCB_READONLY)));
49325 }
49326 {
49327 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int(static_cast<int >(wxRA_HORIZONTAL)));
49328 }
49329 {
49330 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int(static_cast<int >(wxRA_VERTICAL)));
49331 }
49332 {
49333 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int(static_cast<int >(wxRA_SPECIFY_ROWS)));
49334 }
49335 {
49336 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int(static_cast<int >(wxRA_SPECIFY_COLS)));
49337 }
49338 {
49339 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int(static_cast<int >(wxRA_USE_CHECKBOX)));
49340 }
49341 {
49342 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int(static_cast<int >(wxRB_GROUP)));
49343 }
49344 {
49345 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int(static_cast<int >(wxRB_SINGLE)));
49346 }
49347 {
49348 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int(static_cast<int >(wxSB_HORIZONTAL)));
49349 }
49350 {
49351 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int(static_cast<int >(wxSB_VERTICAL)));
49352 }
49353 {
49354 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int(static_cast<int >(wxRB_USE_CHECKBOX)));
49355 }
49356 {
49357 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int(static_cast<int >(wxST_SIZEGRIP)));
49358 }
49359 {
49360 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int(static_cast<int >(wxST_NO_AUTORESIZE)));
49361 }
49362 {
49363 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int(static_cast<int >(wxFLOOD_SURFACE)));
49364 }
49365 {
49366 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int(static_cast<int >(wxFLOOD_BORDER)));
49367 }
49368 {
49369 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int(static_cast<int >(wxODDEVEN_RULE)));
49370 }
49371 {
49372 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int(static_cast<int >(wxWINDING_RULE)));
49373 }
49374 {
49375 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int(static_cast<int >(wxTOOL_TOP)));
49376 }
49377 {
49378 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int(static_cast<int >(wxTOOL_BOTTOM)));
49379 }
49380 {
49381 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int(static_cast<int >(wxTOOL_LEFT)));
49382 }
49383 {
49384 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int(static_cast<int >(wxTOOL_RIGHT)));
49385 }
49386 {
49387 PyDict_SetItemString(d,"OK", SWIG_From_int(static_cast<int >(wxOK)));
49388 }
49389 {
49390 PyDict_SetItemString(d,"YES_NO", SWIG_From_int(static_cast<int >(wxYES_NO)));
49391 }
49392 {
49393 PyDict_SetItemString(d,"CANCEL", SWIG_From_int(static_cast<int >(wxCANCEL)));
49394 }
49395 {
49396 PyDict_SetItemString(d,"YES", SWIG_From_int(static_cast<int >(wxYES)));
49397 }
49398 {
49399 PyDict_SetItemString(d,"NO", SWIG_From_int(static_cast<int >(wxNO)));
49400 }
49401 {
49402 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int(static_cast<int >(wxNO_DEFAULT)));
49403 }
49404 {
49405 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int(static_cast<int >(wxYES_DEFAULT)));
49406 }
49407 {
49408 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int(static_cast<int >(wxICON_EXCLAMATION)));
49409 }
49410 {
49411 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int(static_cast<int >(wxICON_HAND)));
49412 }
49413 {
49414 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int(static_cast<int >(wxICON_QUESTION)));
49415 }
49416 {
49417 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int(static_cast<int >(wxICON_INFORMATION)));
49418 }
49419 {
49420 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int(static_cast<int >(wxICON_STOP)));
49421 }
49422 {
49423 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int(static_cast<int >(wxICON_ASTERISK)));
49424 }
49425 {
49426 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int(static_cast<int >(wxICON_MASK)));
49427 }
49428 {
49429 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int(static_cast<int >(wxICON_WARNING)));
49430 }
49431 {
49432 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int(static_cast<int >(wxICON_ERROR)));
49433 }
49434 {
49435 PyDict_SetItemString(d,"FORWARD", SWIG_From_int(static_cast<int >(wxFORWARD)));
49436 }
49437 {
49438 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int(static_cast<int >(wxBACKWARD)));
49439 }
49440 {
49441 PyDict_SetItemString(d,"RESET", SWIG_From_int(static_cast<int >(wxRESET)));
49442 }
49443 {
49444 PyDict_SetItemString(d,"HELP", SWIG_From_int(static_cast<int >(wxHELP)));
49445 }
49446 {
49447 PyDict_SetItemString(d,"MORE", SWIG_From_int(static_cast<int >(wxMORE)));
49448 }
49449 {
49450 PyDict_SetItemString(d,"SETUP", SWIG_From_int(static_cast<int >(wxSETUP)));
49451 }
49452 {
49453 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int(static_cast<int >(wxSIZE_AUTO_WIDTH)));
49454 }
49455 {
49456 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int(static_cast<int >(wxSIZE_AUTO_HEIGHT)));
49457 }
49458 {
49459 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int(static_cast<int >(wxSIZE_AUTO)));
49460 }
49461 {
49462 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int(static_cast<int >(wxSIZE_USE_EXISTING)));
49463 }
49464 {
49465 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int(static_cast<int >(wxSIZE_ALLOW_MINUS_ONE)));
49466 }
49467 {
49468 PyDict_SetItemString(d,"SIZE_FORCE", SWIG_From_int(static_cast<int >(wxSIZE_FORCE)));
49469 }
49470 {
49471 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int(static_cast<int >(wxPORTRAIT)));
49472 }
49473 {
49474 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int(static_cast<int >(wxLANDSCAPE)));
49475 }
49476 {
49477 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_HIGH)));
49478 }
49479 {
49480 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_MEDIUM)));
49481 }
49482 {
49483 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_LOW)));
49484 }
49485 {
49486 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_DRAFT)));
49487 }
49488 {
49489 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int(static_cast<int >(wxID_ANY)));
49490 }
49491 {
49492 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int(static_cast<int >(wxID_SEPARATOR)));
49493 }
49494 {
49495 PyDict_SetItemString(d,"ID_NONE", SWIG_From_int(static_cast<int >(wxID_NONE)));
49496 }
49497 {
49498 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int(static_cast<int >(wxID_LOWEST)));
49499 }
49500 {
49501 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int(static_cast<int >(wxID_OPEN)));
49502 }
49503 {
49504 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int(static_cast<int >(wxID_CLOSE)));
49505 }
49506 {
49507 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int(static_cast<int >(wxID_NEW)));
49508 }
49509 {
49510 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int(static_cast<int >(wxID_SAVE)));
49511 }
49512 {
49513 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int(static_cast<int >(wxID_SAVEAS)));
49514 }
49515 {
49516 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int(static_cast<int >(wxID_REVERT)));
49517 }
49518 {
49519 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int(static_cast<int >(wxID_EXIT)));
49520 }
49521 {
49522 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int(static_cast<int >(wxID_UNDO)));
49523 }
49524 {
49525 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int(static_cast<int >(wxID_REDO)));
49526 }
49527 {
49528 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int(static_cast<int >(wxID_HELP)));
49529 }
49530 {
49531 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int(static_cast<int >(wxID_PRINT)));
49532 }
49533 {
49534 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int(static_cast<int >(wxID_PRINT_SETUP)));
49535 }
49536 {
49537 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int(static_cast<int >(wxID_PREVIEW)));
49538 }
49539 {
49540 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int(static_cast<int >(wxID_ABOUT)));
49541 }
49542 {
49543 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int(static_cast<int >(wxID_HELP_CONTENTS)));
49544 }
49545 {
49546 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int(static_cast<int >(wxID_HELP_COMMANDS)));
49547 }
49548 {
49549 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int(static_cast<int >(wxID_HELP_PROCEDURES)));
49550 }
49551 {
49552 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int(static_cast<int >(wxID_HELP_CONTEXT)));
49553 }
49554 {
49555 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int(static_cast<int >(wxID_CLOSE_ALL)));
49556 }
49557 {
49558 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int(static_cast<int >(wxID_PREFERENCES)));
49559 }
49560 {
49561 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int(static_cast<int >(wxID_CUT)));
49562 }
49563 {
49564 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int(static_cast<int >(wxID_COPY)));
49565 }
49566 {
49567 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int(static_cast<int >(wxID_PASTE)));
49568 }
49569 {
49570 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int(static_cast<int >(wxID_CLEAR)));
49571 }
49572 {
49573 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int(static_cast<int >(wxID_FIND)));
49574 }
49575 {
49576 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int(static_cast<int >(wxID_DUPLICATE)));
49577 }
49578 {
49579 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int(static_cast<int >(wxID_SELECTALL)));
49580 }
49581 {
49582 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int(static_cast<int >(wxID_DELETE)));
49583 }
49584 {
49585 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int(static_cast<int >(wxID_REPLACE)));
49586 }
49587 {
49588 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int(static_cast<int >(wxID_REPLACE_ALL)));
49589 }
49590 {
49591 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int(static_cast<int >(wxID_PROPERTIES)));
49592 }
49593 {
49594 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int(static_cast<int >(wxID_VIEW_DETAILS)));
49595 }
49596 {
49597 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int(static_cast<int >(wxID_VIEW_LARGEICONS)));
49598 }
49599 {
49600 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int(static_cast<int >(wxID_VIEW_SMALLICONS)));
49601 }
49602 {
49603 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int(static_cast<int >(wxID_VIEW_LIST)));
49604 }
49605 {
49606 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTDATE)));
49607 }
49608 {
49609 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTNAME)));
49610 }
49611 {
49612 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTSIZE)));
49613 }
49614 {
49615 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTTYPE)));
49616 }
49617 {
49618 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int(static_cast<int >(wxID_FILE1)));
49619 }
49620 {
49621 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int(static_cast<int >(wxID_FILE2)));
49622 }
49623 {
49624 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int(static_cast<int >(wxID_FILE3)));
49625 }
49626 {
49627 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int(static_cast<int >(wxID_FILE4)));
49628 }
49629 {
49630 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int(static_cast<int >(wxID_FILE5)));
49631 }
49632 {
49633 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int(static_cast<int >(wxID_FILE6)));
49634 }
49635 {
49636 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int(static_cast<int >(wxID_FILE7)));
49637 }
49638 {
49639 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int(static_cast<int >(wxID_FILE8)));
49640 }
49641 {
49642 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int(static_cast<int >(wxID_FILE9)));
49643 }
49644 {
49645 PyDict_SetItemString(d,"ID_OK", SWIG_From_int(static_cast<int >(wxID_OK)));
49646 }
49647 {
49648 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int(static_cast<int >(wxID_CANCEL)));
49649 }
49650 {
49651 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int(static_cast<int >(wxID_APPLY)));
49652 }
49653 {
49654 PyDict_SetItemString(d,"ID_YES", SWIG_From_int(static_cast<int >(wxID_YES)));
49655 }
49656 {
49657 PyDict_SetItemString(d,"ID_NO", SWIG_From_int(static_cast<int >(wxID_NO)));
49658 }
49659 {
49660 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int(static_cast<int >(wxID_STATIC)));
49661 }
49662 {
49663 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int(static_cast<int >(wxID_FORWARD)));
49664 }
49665 {
49666 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int(static_cast<int >(wxID_BACKWARD)));
49667 }
49668 {
49669 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int(static_cast<int >(wxID_DEFAULT)));
49670 }
49671 {
49672 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int(static_cast<int >(wxID_MORE)));
49673 }
49674 {
49675 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int(static_cast<int >(wxID_SETUP)));
49676 }
49677 {
49678 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int(static_cast<int >(wxID_RESET)));
49679 }
49680 {
49681 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int(static_cast<int >(wxID_CONTEXT_HELP)));
49682 }
49683 {
49684 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int(static_cast<int >(wxID_YESTOALL)));
49685 }
49686 {
49687 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int(static_cast<int >(wxID_NOTOALL)));
49688 }
49689 {
49690 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int(static_cast<int >(wxID_ABORT)));
49691 }
49692 {
49693 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int(static_cast<int >(wxID_RETRY)));
49694 }
49695 {
49696 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int(static_cast<int >(wxID_IGNORE)));
49697 }
49698 {
49699 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int(static_cast<int >(wxID_ADD)));
49700 }
49701 {
49702 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int(static_cast<int >(wxID_REMOVE)));
49703 }
49704 {
49705 PyDict_SetItemString(d,"ID_UP", SWIG_From_int(static_cast<int >(wxID_UP)));
49706 }
49707 {
49708 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int(static_cast<int >(wxID_DOWN)));
49709 }
49710 {
49711 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int(static_cast<int >(wxID_HOME)));
49712 }
49713 {
49714 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int(static_cast<int >(wxID_REFRESH)));
49715 }
49716 {
49717 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int(static_cast<int >(wxID_STOP)));
49718 }
49719 {
49720 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int(static_cast<int >(wxID_INDEX)));
49721 }
49722 {
49723 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int(static_cast<int >(wxID_BOLD)));
49724 }
49725 {
49726 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int(static_cast<int >(wxID_ITALIC)));
49727 }
49728 {
49729 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_CENTER)));
49730 }
49731 {
49732 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_FILL)));
49733 }
49734 {
49735 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_RIGHT)));
49736 }
49737 {
49738 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_LEFT)));
49739 }
49740 {
49741 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int(static_cast<int >(wxID_UNDERLINE)));
49742 }
49743 {
49744 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int(static_cast<int >(wxID_INDENT)));
49745 }
49746 {
49747 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int(static_cast<int >(wxID_UNINDENT)));
49748 }
49749 {
49750 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int(static_cast<int >(wxID_ZOOM_100)));
49751 }
49752 {
49753 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int(static_cast<int >(wxID_ZOOM_FIT)));
49754 }
49755 {
49756 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int(static_cast<int >(wxID_ZOOM_IN)));
49757 }
49758 {
49759 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int(static_cast<int >(wxID_ZOOM_OUT)));
49760 }
49761 {
49762 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int(static_cast<int >(wxID_UNDELETE)));
49763 }
49764 {
49765 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int(static_cast<int >(wxID_REVERT_TO_SAVED)));
49766 }
49767 {
49768 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int(static_cast<int >(wxID_HIGHEST)));
49769 }
49770 {
49771 PyDict_SetItemString(d,"OPEN", SWIG_From_int(static_cast<int >(wxOPEN)));
49772 }
49773 {
49774 PyDict_SetItemString(d,"SAVE", SWIG_From_int(static_cast<int >(wxSAVE)));
49775 }
49776 {
49777 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int(static_cast<int >(wxHIDE_READONLY)));
49778 }
49779 {
49780 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int(static_cast<int >(wxOVERWRITE_PROMPT)));
49781 }
49782 {
49783 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int(static_cast<int >(wxFILE_MUST_EXIST)));
49784 }
49785 {
49786 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int(static_cast<int >(wxMULTIPLE)));
49787 }
49788 {
49789 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int(static_cast<int >(wxCHANGE_DIR)));
49790 }
49791 {
49792 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int(static_cast<int >(wxACCEL_ALT)));
49793 }
49794 {
49795 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int(static_cast<int >(wxACCEL_CTRL)));
49796 }
49797 {
49798 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int(static_cast<int >(wxACCEL_SHIFT)));
49799 }
49800 {
49801 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int(static_cast<int >(wxACCEL_NORMAL)));
49802 }
49803 {
49804 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int(static_cast<int >(wxPD_AUTO_HIDE)));
49805 }
49806 {
49807 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int(static_cast<int >(wxPD_APP_MODAL)));
49808 }
49809 {
49810 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int(static_cast<int >(wxPD_CAN_ABORT)));
49811 }
49812 {
49813 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int(static_cast<int >(wxPD_ELAPSED_TIME)));
49814 }
49815 {
49816 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int(static_cast<int >(wxPD_ESTIMATED_TIME)));
49817 }
49818 {
49819 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int(static_cast<int >(wxPD_REMAINING_TIME)));
49820 }
49821 {
49822 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int(static_cast<int >(wxPD_SMOOTH)));
49823 }
49824 {
49825 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int(static_cast<int >(wxPD_CAN_SKIP)));
49826 }
49827 {
49828 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int(static_cast<int >(wxDD_NEW_DIR_BUTTON)));
49829 }
49830 {
49831 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int(static_cast<int >(wxDD_DEFAULT_STYLE)));
49832 }
49833 {
49834 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int(static_cast<int >(wxMENU_TEAROFF)));
49835 }
49836 {
49837 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int(static_cast<int >(wxMB_DOCKABLE)));
49838 }
49839 {
49840 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int(static_cast<int >(wxNO_FULL_REPAINT_ON_RESIZE)));
49841 }
49842 {
49843 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int(static_cast<int >(wxFULL_REPAINT_ON_RESIZE)));
49844 }
49845 {
49846 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int(static_cast<int >(wxLI_HORIZONTAL)));
49847 }
49848 {
49849 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int(static_cast<int >(wxLI_VERTICAL)));
49850 }
49851 {
49852 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int(static_cast<int >(wxWS_EX_VALIDATE_RECURSIVELY)));
49853 }
49854 {
49855 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int(static_cast<int >(wxWS_EX_BLOCK_EVENTS)));
49856 }
49857 {
49858 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int(static_cast<int >(wxWS_EX_TRANSIENT)));
49859 }
49860 {
49861 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int(static_cast<int >(wxWS_EX_THEMED_BACKGROUND)));
49862 }
49863 {
49864 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int(static_cast<int >(wxWS_EX_PROCESS_IDLE)));
49865 }
49866 {
49867 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int(static_cast<int >(wxWS_EX_PROCESS_UI_UPDATES)));
49868 }
49869 {
49870 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int(static_cast<int >(wxMM_TEXT)));
49871 }
49872 {
49873 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int(static_cast<int >(wxMM_LOMETRIC)));
49874 }
49875 {
49876 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int(static_cast<int >(wxMM_HIMETRIC)));
49877 }
49878 {
49879 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int(static_cast<int >(wxMM_LOENGLISH)));
49880 }
49881 {
49882 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int(static_cast<int >(wxMM_HIENGLISH)));
49883 }
49884 {
49885 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int(static_cast<int >(wxMM_TWIPS)));
49886 }
49887 {
49888 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int(static_cast<int >(wxMM_ISOTROPIC)));
49889 }
49890 {
49891 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int(static_cast<int >(wxMM_ANISOTROPIC)));
49892 }
49893 {
49894 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int(static_cast<int >(wxMM_POINTS)));
49895 }
49896 {
49897 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int(static_cast<int >(wxMM_METRIC)));
49898 }
49899 {
49900 PyDict_SetItemString(d,"CENTRE", SWIG_From_int(static_cast<int >(wxCENTRE)));
49901 }
49902 {
49903 PyDict_SetItemString(d,"CENTER", SWIG_From_int(static_cast<int >(wxCENTER)));
49904 }
49905 {
49906 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int(static_cast<int >(wxHORIZONTAL)));
49907 }
49908 {
49909 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int(static_cast<int >(wxVERTICAL)));
49910 }
49911 {
49912 PyDict_SetItemString(d,"BOTH", SWIG_From_int(static_cast<int >(wxBOTH)));
49913 }
49914 {
49915 PyDict_SetItemString(d,"LEFT", SWIG_From_int(static_cast<int >(wxLEFT)));
49916 }
49917 {
49918 PyDict_SetItemString(d,"RIGHT", SWIG_From_int(static_cast<int >(wxRIGHT)));
49919 }
49920 {
49921 PyDict_SetItemString(d,"UP", SWIG_From_int(static_cast<int >(wxUP)));
49922 }
49923 {
49924 PyDict_SetItemString(d,"DOWN", SWIG_From_int(static_cast<int >(wxDOWN)));
49925 }
49926 {
49927 PyDict_SetItemString(d,"TOP", SWIG_From_int(static_cast<int >(wxTOP)));
49928 }
49929 {
49930 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int(static_cast<int >(wxBOTTOM)));
49931 }
49932 {
49933 PyDict_SetItemString(d,"NORTH", SWIG_From_int(static_cast<int >(wxNORTH)));
49934 }
49935 {
49936 PyDict_SetItemString(d,"SOUTH", SWIG_From_int(static_cast<int >(wxSOUTH)));
49937 }
49938 {
49939 PyDict_SetItemString(d,"WEST", SWIG_From_int(static_cast<int >(wxWEST)));
49940 }
49941 {
49942 PyDict_SetItemString(d,"EAST", SWIG_From_int(static_cast<int >(wxEAST)));
49943 }
49944 {
49945 PyDict_SetItemString(d,"ALL", SWIG_From_int(static_cast<int >(wxALL)));
49946 }
49947 {
49948 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int(static_cast<int >(wxALIGN_NOT)));
49949 }
49950 {
49951 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTER_HORIZONTAL)));
49952 }
49953 {
49954 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE_HORIZONTAL)));
49955 }
49956 {
49957 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int(static_cast<int >(wxALIGN_LEFT)));
49958 }
49959 {
49960 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int(static_cast<int >(wxALIGN_TOP)));
49961 }
49962 {
49963 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int(static_cast<int >(wxALIGN_RIGHT)));
49964 }
49965 {
49966 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int(static_cast<int >(wxALIGN_BOTTOM)));
49967 }
49968 {
49969 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTER_VERTICAL)));
49970 }
49971 {
49972 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE_VERTICAL)));
49973 }
49974 {
49975 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int(static_cast<int >(wxALIGN_CENTER)));
49976 }
49977 {
49978 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE)));
49979 }
49980 {
49981 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int(static_cast<int >(wxALIGN_MASK)));
49982 }
49983 {
49984 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int(static_cast<int >(wxSTRETCH_NOT)));
49985 }
49986 {
49987 PyDict_SetItemString(d,"SHRINK", SWIG_From_int(static_cast<int >(wxSHRINK)));
49988 }
49989 {
49990 PyDict_SetItemString(d,"GROW", SWIG_From_int(static_cast<int >(wxGROW)));
49991 }
49992 {
49993 PyDict_SetItemString(d,"EXPAND", SWIG_From_int(static_cast<int >(wxEXPAND)));
49994 }
49995 {
49996 PyDict_SetItemString(d,"SHAPED", SWIG_From_int(static_cast<int >(wxSHAPED)));
49997 }
49998 {
49999 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int(static_cast<int >(wxFIXED_MINSIZE)));
50000 }
50001 {
50002 PyDict_SetItemString(d,"TILE", SWIG_From_int(static_cast<int >(wxTILE)));
50003 }
50004 {
50005 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int(static_cast<int >(wxADJUST_MINSIZE)));
50006 }
50007 {
50008 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int(static_cast<int >(wxBORDER_DEFAULT)));
50009 }
50010 {
50011 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int(static_cast<int >(wxBORDER_NONE)));
50012 }
50013 {
50014 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int(static_cast<int >(wxBORDER_STATIC)));
50015 }
50016 {
50017 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int(static_cast<int >(wxBORDER_SIMPLE)));
50018 }
50019 {
50020 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int(static_cast<int >(wxBORDER_RAISED)));
50021 }
50022 {
50023 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int(static_cast<int >(wxBORDER_SUNKEN)));
50024 }
50025 {
50026 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int(static_cast<int >(wxBORDER_DOUBLE)));
50027 }
50028 {
50029 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int(static_cast<int >(wxBORDER_MASK)));
50030 }
50031 {
50032 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int(static_cast<int >(wxBG_STYLE_SYSTEM)));
50033 }
50034 {
50035 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int(static_cast<int >(wxBG_STYLE_COLOUR)));
50036 }
50037 {
50038 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int(static_cast<int >(wxBG_STYLE_CUSTOM)));
50039 }
50040 {
50041 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int(static_cast<int >(wxDEFAULT)));
50042 }
50043 {
50044 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int(static_cast<int >(wxDECORATIVE)));
50045 }
50046 {
50047 PyDict_SetItemString(d,"ROMAN", SWIG_From_int(static_cast<int >(wxROMAN)));
50048 }
50049 {
50050 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int(static_cast<int >(wxSCRIPT)));
50051 }
50052 {
50053 PyDict_SetItemString(d,"SWISS", SWIG_From_int(static_cast<int >(wxSWISS)));
50054 }
50055 {
50056 PyDict_SetItemString(d,"MODERN", SWIG_From_int(static_cast<int >(wxMODERN)));
50057 }
50058 {
50059 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int(static_cast<int >(wxTELETYPE)));
50060 }
50061 {
50062 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int(static_cast<int >(wxVARIABLE)));
50063 }
50064 {
50065 PyDict_SetItemString(d,"FIXED", SWIG_From_int(static_cast<int >(wxFIXED)));
50066 }
50067 {
50068 PyDict_SetItemString(d,"NORMAL", SWIG_From_int(static_cast<int >(wxNORMAL)));
50069 }
50070 {
50071 PyDict_SetItemString(d,"LIGHT", SWIG_From_int(static_cast<int >(wxLIGHT)));
50072 }
50073 {
50074 PyDict_SetItemString(d,"BOLD", SWIG_From_int(static_cast<int >(wxBOLD)));
50075 }
50076 {
50077 PyDict_SetItemString(d,"ITALIC", SWIG_From_int(static_cast<int >(wxITALIC)));
50078 }
50079 {
50080 PyDict_SetItemString(d,"SLANT", SWIG_From_int(static_cast<int >(wxSLANT)));
50081 }
50082 {
50083 PyDict_SetItemString(d,"SOLID", SWIG_From_int(static_cast<int >(wxSOLID)));
50084 }
50085 {
50086 PyDict_SetItemString(d,"DOT", SWIG_From_int(static_cast<int >(wxDOT)));
50087 }
50088 {
50089 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int(static_cast<int >(wxLONG_DASH)));
50090 }
50091 {
50092 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int(static_cast<int >(wxSHORT_DASH)));
50093 }
50094 {
50095 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int(static_cast<int >(wxDOT_DASH)));
50096 }
50097 {
50098 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int(static_cast<int >(wxUSER_DASH)));
50099 }
50100 {
50101 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int(static_cast<int >(wxTRANSPARENT)));
50102 }
50103 {
50104 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int(static_cast<int >(wxSTIPPLE)));
50105 }
50106 {
50107 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int(static_cast<int >(wxSTIPPLE_MASK)));
50108 }
50109 {
50110 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int(static_cast<int >(wxSTIPPLE_MASK_OPAQUE)));
50111 }
50112 {
50113 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int(static_cast<int >(wxBDIAGONAL_HATCH)));
50114 }
50115 {
50116 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int(static_cast<int >(wxCROSSDIAG_HATCH)));
50117 }
50118 {
50119 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int(static_cast<int >(wxFDIAGONAL_HATCH)));
50120 }
50121 {
50122 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int(static_cast<int >(wxCROSS_HATCH)));
50123 }
50124 {
50125 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int(static_cast<int >(wxHORIZONTAL_HATCH)));
50126 }
50127 {
50128 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int(static_cast<int >(wxVERTICAL_HATCH)));
50129 }
50130 {
50131 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int(static_cast<int >(wxJOIN_BEVEL)));
50132 }
50133 {
50134 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int(static_cast<int >(wxJOIN_MITER)));
50135 }
50136 {
50137 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int(static_cast<int >(wxJOIN_ROUND)));
50138 }
50139 {
50140 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int(static_cast<int >(wxCAP_ROUND)));
50141 }
50142 {
50143 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int(static_cast<int >(wxCAP_PROJECTING)));
50144 }
50145 {
50146 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int(static_cast<int >(wxCAP_BUTT)));
50147 }
50148 {
50149 PyDict_SetItemString(d,"CLEAR", SWIG_From_int(static_cast<int >(wxCLEAR)));
50150 }
50151 {
50152 PyDict_SetItemString(d,"XOR", SWIG_From_int(static_cast<int >(wxXOR)));
50153 }
50154 {
50155 PyDict_SetItemString(d,"INVERT", SWIG_From_int(static_cast<int >(wxINVERT)));
50156 }
50157 {
50158 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int(static_cast<int >(wxOR_REVERSE)));
50159 }
50160 {
50161 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int(static_cast<int >(wxAND_REVERSE)));
50162 }
50163 {
50164 PyDict_SetItemString(d,"COPY", SWIG_From_int(static_cast<int >(wxCOPY)));
50165 }
50166 {
50167 PyDict_SetItemString(d,"AND", SWIG_From_int(static_cast<int >(wxAND)));
50168 }
50169 {
50170 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int(static_cast<int >(wxAND_INVERT)));
50171 }
50172 {
50173 PyDict_SetItemString(d,"NO_OP", SWIG_From_int(static_cast<int >(wxNO_OP)));
50174 }
50175 {
50176 PyDict_SetItemString(d,"NOR", SWIG_From_int(static_cast<int >(wxNOR)));
50177 }
50178 {
50179 PyDict_SetItemString(d,"EQUIV", SWIG_From_int(static_cast<int >(wxEQUIV)));
50180 }
50181 {
50182 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int(static_cast<int >(wxSRC_INVERT)));
50183 }
50184 {
50185 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int(static_cast<int >(wxOR_INVERT)));
50186 }
50187 {
50188 PyDict_SetItemString(d,"NAND", SWIG_From_int(static_cast<int >(wxNAND)));
50189 }
50190 {
50191 PyDict_SetItemString(d,"OR", SWIG_From_int(static_cast<int >(wxOR)));
50192 }
50193 {
50194 PyDict_SetItemString(d,"SET", SWIG_From_int(static_cast<int >(wxSET)));
50195 }
50196 {
50197 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int(static_cast<int >(WXK_BACK)));
50198 }
50199 {
50200 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int(static_cast<int >(WXK_TAB)));
50201 }
50202 {
50203 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int(static_cast<int >(WXK_RETURN)));
50204 }
50205 {
50206 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int(static_cast<int >(WXK_ESCAPE)));
50207 }
50208 {
50209 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int(static_cast<int >(WXK_SPACE)));
50210 }
50211 {
50212 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int(static_cast<int >(WXK_DELETE)));
50213 }
50214 {
50215 PyDict_SetItemString(d,"WXK_START", SWIG_From_int(static_cast<int >(WXK_START)));
50216 }
50217 {
50218 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int(static_cast<int >(WXK_LBUTTON)));
50219 }
50220 {
50221 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int(static_cast<int >(WXK_RBUTTON)));
50222 }
50223 {
50224 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int(static_cast<int >(WXK_CANCEL)));
50225 }
50226 {
50227 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int(static_cast<int >(WXK_MBUTTON)));
50228 }
50229 {
50230 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int(static_cast<int >(WXK_CLEAR)));
50231 }
50232 {
50233 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int(static_cast<int >(WXK_SHIFT)));
50234 }
50235 {
50236 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int(static_cast<int >(WXK_ALT)));
50237 }
50238 {
50239 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int(static_cast<int >(WXK_CONTROL)));
50240 }
50241 {
50242 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int(static_cast<int >(WXK_MENU)));
50243 }
50244 {
50245 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int(static_cast<int >(WXK_PAUSE)));
50246 }
50247 {
50248 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int(static_cast<int >(WXK_CAPITAL)));
50249 }
50250 {
50251 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int(static_cast<int >(WXK_PRIOR)));
50252 }
50253 {
50254 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int(static_cast<int >(WXK_NEXT)));
50255 }
50256 {
50257 PyDict_SetItemString(d,"WXK_END", SWIG_From_int(static_cast<int >(WXK_END)));
50258 }
50259 {
50260 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int(static_cast<int >(WXK_HOME)));
50261 }
50262 {
50263 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int(static_cast<int >(WXK_LEFT)));
50264 }
50265 {
50266 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int(static_cast<int >(WXK_UP)));
50267 }
50268 {
50269 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int(static_cast<int >(WXK_RIGHT)));
50270 }
50271 {
50272 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int(static_cast<int >(WXK_DOWN)));
50273 }
50274 {
50275 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int(static_cast<int >(WXK_SELECT)));
50276 }
50277 {
50278 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int(static_cast<int >(WXK_PRINT)));
50279 }
50280 {
50281 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int(static_cast<int >(WXK_EXECUTE)));
50282 }
50283 {
50284 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int(static_cast<int >(WXK_SNAPSHOT)));
50285 }
50286 {
50287 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int(static_cast<int >(WXK_INSERT)));
50288 }
50289 {
50290 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int(static_cast<int >(WXK_HELP)));
50291 }
50292 {
50293 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int(static_cast<int >(WXK_NUMPAD0)));
50294 }
50295 {
50296 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int(static_cast<int >(WXK_NUMPAD1)));
50297 }
50298 {
50299 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int(static_cast<int >(WXK_NUMPAD2)));
50300 }
50301 {
50302 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int(static_cast<int >(WXK_NUMPAD3)));
50303 }
50304 {
50305 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int(static_cast<int >(WXK_NUMPAD4)));
50306 }
50307 {
50308 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int(static_cast<int >(WXK_NUMPAD5)));
50309 }
50310 {
50311 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int(static_cast<int >(WXK_NUMPAD6)));
50312 }
50313 {
50314 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int(static_cast<int >(WXK_NUMPAD7)));
50315 }
50316 {
50317 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int(static_cast<int >(WXK_NUMPAD8)));
50318 }
50319 {
50320 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int(static_cast<int >(WXK_NUMPAD9)));
50321 }
50322 {
50323 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int(static_cast<int >(WXK_MULTIPLY)));
50324 }
50325 {
50326 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int(static_cast<int >(WXK_ADD)));
50327 }
50328 {
50329 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int(static_cast<int >(WXK_SEPARATOR)));
50330 }
50331 {
50332 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int(static_cast<int >(WXK_SUBTRACT)));
50333 }
50334 {
50335 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int(static_cast<int >(WXK_DECIMAL)));
50336 }
50337 {
50338 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int(static_cast<int >(WXK_DIVIDE)));
50339 }
50340 {
50341 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int(static_cast<int >(WXK_F1)));
50342 }
50343 {
50344 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int(static_cast<int >(WXK_F2)));
50345 }
50346 {
50347 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int(static_cast<int >(WXK_F3)));
50348 }
50349 {
50350 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int(static_cast<int >(WXK_F4)));
50351 }
50352 {
50353 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int(static_cast<int >(WXK_F5)));
50354 }
50355 {
50356 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int(static_cast<int >(WXK_F6)));
50357 }
50358 {
50359 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int(static_cast<int >(WXK_F7)));
50360 }
50361 {
50362 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int(static_cast<int >(WXK_F8)));
50363 }
50364 {
50365 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int(static_cast<int >(WXK_F9)));
50366 }
50367 {
50368 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int(static_cast<int >(WXK_F10)));
50369 }
50370 {
50371 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int(static_cast<int >(WXK_F11)));
50372 }
50373 {
50374 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int(static_cast<int >(WXK_F12)));
50375 }
50376 {
50377 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int(static_cast<int >(WXK_F13)));
50378 }
50379 {
50380 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int(static_cast<int >(WXK_F14)));
50381 }
50382 {
50383 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int(static_cast<int >(WXK_F15)));
50384 }
50385 {
50386 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int(static_cast<int >(WXK_F16)));
50387 }
50388 {
50389 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int(static_cast<int >(WXK_F17)));
50390 }
50391 {
50392 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int(static_cast<int >(WXK_F18)));
50393 }
50394 {
50395 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int(static_cast<int >(WXK_F19)));
50396 }
50397 {
50398 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int(static_cast<int >(WXK_F20)));
50399 }
50400 {
50401 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int(static_cast<int >(WXK_F21)));
50402 }
50403 {
50404 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int(static_cast<int >(WXK_F22)));
50405 }
50406 {
50407 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int(static_cast<int >(WXK_F23)));
50408 }
50409 {
50410 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int(static_cast<int >(WXK_F24)));
50411 }
50412 {
50413 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int(static_cast<int >(WXK_NUMLOCK)));
50414 }
50415 {
50416 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int(static_cast<int >(WXK_SCROLL)));
50417 }
50418 {
50419 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int(static_cast<int >(WXK_PAGEUP)));
50420 }
50421 {
50422 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int(static_cast<int >(WXK_PAGEDOWN)));
50423 }
50424 {
50425 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SPACE)));
50426 }
50427 {
50428 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int(static_cast<int >(WXK_NUMPAD_TAB)));
50429 }
50430 {
50431 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int(static_cast<int >(WXK_NUMPAD_ENTER)));
50432 }
50433 {
50434 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F1)));
50435 }
50436 {
50437 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F2)));
50438 }
50439 {
50440 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F3)));
50441 }
50442 {
50443 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F4)));
50444 }
50445 {
50446 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int(static_cast<int >(WXK_NUMPAD_HOME)));
50447 }
50448 {
50449 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_LEFT)));
50450 }
50451 {
50452 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int(static_cast<int >(WXK_NUMPAD_UP)));
50453 }
50454 {
50455 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_RIGHT)));
50456 }
50457 {
50458 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DOWN)));
50459 }
50460 {
50461 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PRIOR)));
50462 }
50463 {
50464 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PAGEUP)));
50465 }
50466 {
50467 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_NEXT)));
50468 }
50469 {
50470 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PAGEDOWN)));
50471 }
50472 {
50473 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int(static_cast<int >(WXK_NUMPAD_END)));
50474 }
50475 {
50476 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_BEGIN)));
50477 }
50478 {
50479 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_INSERT)));
50480 }
50481 {
50482 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DELETE)));
50483 }
50484 {
50485 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int(static_cast<int >(WXK_NUMPAD_EQUAL)));
50486 }
50487 {
50488 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int(static_cast<int >(WXK_NUMPAD_MULTIPLY)));
50489 }
50490 {
50491 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int(static_cast<int >(WXK_NUMPAD_ADD)));
50492 }
50493 {
50494 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SEPARATOR)));
50495 }
50496 {
50497 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SUBTRACT)));
50498 }
50499 {
50500 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DECIMAL)));
50501 }
50502 {
50503 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DIVIDE)));
50504 }
50505 {
50506 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int(static_cast<int >(WXK_WINDOWS_LEFT)));
50507 }
50508 {
50509 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int(static_cast<int >(WXK_WINDOWS_RIGHT)));
50510 }
50511 {
50512 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int(static_cast<int >(WXK_WINDOWS_MENU)));
50513 }
50514 {
50515 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int(static_cast<int >(WXK_COMMAND)));
50516 }
50517 {
50518 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int(static_cast<int >(WXK_SPECIAL1)));
50519 }
50520 {
50521 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int(static_cast<int >(WXK_SPECIAL2)));
50522 }
50523 {
50524 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int(static_cast<int >(WXK_SPECIAL3)));
50525 }
50526 {
50527 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int(static_cast<int >(WXK_SPECIAL4)));
50528 }
50529 {
50530 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int(static_cast<int >(WXK_SPECIAL5)));
50531 }
50532 {
50533 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int(static_cast<int >(WXK_SPECIAL6)));
50534 }
50535 {
50536 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int(static_cast<int >(WXK_SPECIAL7)));
50537 }
50538 {
50539 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int(static_cast<int >(WXK_SPECIAL8)));
50540 }
50541 {
50542 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int(static_cast<int >(WXK_SPECIAL9)));
50543 }
50544 {
50545 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int(static_cast<int >(WXK_SPECIAL10)));
50546 }
50547 {
50548 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int(static_cast<int >(WXK_SPECIAL11)));
50549 }
50550 {
50551 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int(static_cast<int >(WXK_SPECIAL12)));
50552 }
50553 {
50554 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int(static_cast<int >(WXK_SPECIAL13)));
50555 }
50556 {
50557 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int(static_cast<int >(WXK_SPECIAL14)));
50558 }
50559 {
50560 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int(static_cast<int >(WXK_SPECIAL15)));
50561 }
50562 {
50563 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int(static_cast<int >(WXK_SPECIAL16)));
50564 }
50565 {
50566 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int(static_cast<int >(WXK_SPECIAL17)));
50567 }
50568 {
50569 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int(static_cast<int >(WXK_SPECIAL18)));
50570 }
50571 {
50572 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int(static_cast<int >(WXK_SPECIAL19)));
50573 }
50574 {
50575 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int(static_cast<int >(WXK_SPECIAL20)));
50576 }
50577 {
50578 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int(static_cast<int >(wxPAPER_NONE)));
50579 }
50580 {
50581 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int(static_cast<int >(wxPAPER_LETTER)));
50582 }
50583 {
50584 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int(static_cast<int >(wxPAPER_LEGAL)));
50585 }
50586 {
50587 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int(static_cast<int >(wxPAPER_A4)));
50588 }
50589 {
50590 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int(static_cast<int >(wxPAPER_CSHEET)));
50591 }
50592 {
50593 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int(static_cast<int >(wxPAPER_DSHEET)));
50594 }
50595 {
50596 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int(static_cast<int >(wxPAPER_ESHEET)));
50597 }
50598 {
50599 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int(static_cast<int >(wxPAPER_LETTERSMALL)));
50600 }
50601 {
50602 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int(static_cast<int >(wxPAPER_TABLOID)));
50603 }
50604 {
50605 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int(static_cast<int >(wxPAPER_LEDGER)));
50606 }
50607 {
50608 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int(static_cast<int >(wxPAPER_STATEMENT)));
50609 }
50610 {
50611 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int(static_cast<int >(wxPAPER_EXECUTIVE)));
50612 }
50613 {
50614 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int(static_cast<int >(wxPAPER_A3)));
50615 }
50616 {
50617 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int(static_cast<int >(wxPAPER_A4SMALL)));
50618 }
50619 {
50620 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int(static_cast<int >(wxPAPER_A5)));
50621 }
50622 {
50623 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int(static_cast<int >(wxPAPER_B4)));
50624 }
50625 {
50626 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int(static_cast<int >(wxPAPER_B5)));
50627 }
50628 {
50629 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int(static_cast<int >(wxPAPER_FOLIO)));
50630 }
50631 {
50632 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int(static_cast<int >(wxPAPER_QUARTO)));
50633 }
50634 {
50635 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int(static_cast<int >(wxPAPER_10X14)));
50636 }
50637 {
50638 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int(static_cast<int >(wxPAPER_11X17)));
50639 }
50640 {
50641 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int(static_cast<int >(wxPAPER_NOTE)));
50642 }
50643 {
50644 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int(static_cast<int >(wxPAPER_ENV_9)));
50645 }
50646 {
50647 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int(static_cast<int >(wxPAPER_ENV_10)));
50648 }
50649 {
50650 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int(static_cast<int >(wxPAPER_ENV_11)));
50651 }
50652 {
50653 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int(static_cast<int >(wxPAPER_ENV_12)));
50654 }
50655 {
50656 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int(static_cast<int >(wxPAPER_ENV_14)));
50657 }
50658 {
50659 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int(static_cast<int >(wxPAPER_ENV_DL)));
50660 }
50661 {
50662 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C5)));
50663 }
50664 {
50665 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C3)));
50666 }
50667 {
50668 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C4)));
50669 }
50670 {
50671 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C6)));
50672 }
50673 {
50674 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C65)));
50675 }
50676 {
50677 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B4)));
50678 }
50679 {
50680 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B5)));
50681 }
50682 {
50683 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B6)));
50684 }
50685 {
50686 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int(static_cast<int >(wxPAPER_ENV_ITALY)));
50687 }
50688 {
50689 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int(static_cast<int >(wxPAPER_ENV_MONARCH)));
50690 }
50691 {
50692 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int(static_cast<int >(wxPAPER_ENV_PERSONAL)));
50693 }
50694 {
50695 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_US)));
50696 }
50697 {
50698 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_STD_GERMAN)));
50699 }
50700 {
50701 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_LGL_GERMAN)));
50702 }
50703 {
50704 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int(static_cast<int >(wxPAPER_ISO_B4)));
50705 }
50706 {
50707 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int(static_cast<int >(wxPAPER_JAPANESE_POSTCARD)));
50708 }
50709 {
50710 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int(static_cast<int >(wxPAPER_9X11)));
50711 }
50712 {
50713 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int(static_cast<int >(wxPAPER_10X11)));
50714 }
50715 {
50716 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int(static_cast<int >(wxPAPER_15X11)));
50717 }
50718 {
50719 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int(static_cast<int >(wxPAPER_ENV_INVITE)));
50720 }
50721 {
50722 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_EXTRA)));
50723 }
50724 {
50725 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_LEGAL_EXTRA)));
50726 }
50727 {
50728 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_TABLOID_EXTRA)));
50729 }
50730 {
50731 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A4_EXTRA)));
50732 }
50733 {
50734 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_TRANSVERSE)));
50735 }
50736 {
50737 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A4_TRANSVERSE)));
50738 }
50739 {
50740 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
50741 }
50742 {
50743 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_A_PLUS)));
50744 }
50745 {
50746 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_B_PLUS)));
50747 }
50748 {
50749 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_PLUS)));
50750 }
50751 {
50752 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_A4_PLUS)));
50753 }
50754 {
50755 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A5_TRANSVERSE)));
50756 }
50757 {
50758 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_B5_TRANSVERSE)));
50759 }
50760 {
50761 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A3_EXTRA)));
50762 }
50763 {
50764 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A5_EXTRA)));
50765 }
50766 {
50767 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_B5_EXTRA)));
50768 }
50769 {
50770 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int(static_cast<int >(wxPAPER_A2)));
50771 }
50772 {
50773 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A3_TRANSVERSE)));
50774 }
50775 {
50776 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
50777 }
50778 {
50779 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD", SWIG_From_int(static_cast<int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
50780 }
50781 {
50782 PyDict_SetItemString(d,"PAPER_A6", SWIG_From_int(static_cast<int >(wxPAPER_A6)));
50783 }
50784 {
50785 PyDict_SetItemString(d,"PAPER_JENV_KAKU2", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU2)));
50786 }
50787 {
50788 PyDict_SetItemString(d,"PAPER_JENV_KAKU3", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU3)));
50789 }
50790 {
50791 PyDict_SetItemString(d,"PAPER_JENV_CHOU3", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU3)));
50792 }
50793 {
50794 PyDict_SetItemString(d,"PAPER_JENV_CHOU4", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU4)));
50795 }
50796 {
50797 PyDict_SetItemString(d,"PAPER_LETTER_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_ROTATED)));
50798 }
50799 {
50800 PyDict_SetItemString(d,"PAPER_A3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A3_ROTATED)));
50801 }
50802 {
50803 PyDict_SetItemString(d,"PAPER_A4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A4_ROTATED)));
50804 }
50805 {
50806 PyDict_SetItemString(d,"PAPER_A5_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A5_ROTATED)));
50807 }
50808 {
50809 PyDict_SetItemString(d,"PAPER_B4_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B4_JIS_ROTATED)));
50810 }
50811 {
50812 PyDict_SetItemString(d,"PAPER_B5_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B5_JIS_ROTATED)));
50813 }
50814 {
50815 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
50816 }
50817 {
50818 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
50819 }
50820 {
50821 PyDict_SetItemString(d,"PAPER_A6_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A6_ROTATED)));
50822 }
50823 {
50824 PyDict_SetItemString(d,"PAPER_JENV_KAKU2_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU2_ROTATED)));
50825 }
50826 {
50827 PyDict_SetItemString(d,"PAPER_JENV_KAKU3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU3_ROTATED)));
50828 }
50829 {
50830 PyDict_SetItemString(d,"PAPER_JENV_CHOU3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU3_ROTATED)));
50831 }
50832 {
50833 PyDict_SetItemString(d,"PAPER_JENV_CHOU4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU4_ROTATED)));
50834 }
50835 {
50836 PyDict_SetItemString(d,"PAPER_B6_JIS", SWIG_From_int(static_cast<int >(wxPAPER_B6_JIS)));
50837 }
50838 {
50839 PyDict_SetItemString(d,"PAPER_B6_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B6_JIS_ROTATED)));
50840 }
50841 {
50842 PyDict_SetItemString(d,"PAPER_12X11", SWIG_From_int(static_cast<int >(wxPAPER_12X11)));
50843 }
50844 {
50845 PyDict_SetItemString(d,"PAPER_JENV_YOU4", SWIG_From_int(static_cast<int >(wxPAPER_JENV_YOU4)));
50846 }
50847 {
50848 PyDict_SetItemString(d,"PAPER_JENV_YOU4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_YOU4_ROTATED)));
50849 }
50850 {
50851 PyDict_SetItemString(d,"PAPER_P16K", SWIG_From_int(static_cast<int >(wxPAPER_P16K)));
50852 }
50853 {
50854 PyDict_SetItemString(d,"PAPER_P32K", SWIG_From_int(static_cast<int >(wxPAPER_P32K)));
50855 }
50856 {
50857 PyDict_SetItemString(d,"PAPER_P32KBIG", SWIG_From_int(static_cast<int >(wxPAPER_P32KBIG)));
50858 }
50859 {
50860 PyDict_SetItemString(d,"PAPER_PENV_1", SWIG_From_int(static_cast<int >(wxPAPER_PENV_1)));
50861 }
50862 {
50863 PyDict_SetItemString(d,"PAPER_PENV_2", SWIG_From_int(static_cast<int >(wxPAPER_PENV_2)));
50864 }
50865 {
50866 PyDict_SetItemString(d,"PAPER_PENV_3", SWIG_From_int(static_cast<int >(wxPAPER_PENV_3)));
50867 }
50868 {
50869 PyDict_SetItemString(d,"PAPER_PENV_4", SWIG_From_int(static_cast<int >(wxPAPER_PENV_4)));
50870 }
50871 {
50872 PyDict_SetItemString(d,"PAPER_PENV_5", SWIG_From_int(static_cast<int >(wxPAPER_PENV_5)));
50873 }
50874 {
50875 PyDict_SetItemString(d,"PAPER_PENV_6", SWIG_From_int(static_cast<int >(wxPAPER_PENV_6)));
50876 }
50877 {
50878 PyDict_SetItemString(d,"PAPER_PENV_7", SWIG_From_int(static_cast<int >(wxPAPER_PENV_7)));
50879 }
50880 {
50881 PyDict_SetItemString(d,"PAPER_PENV_8", SWIG_From_int(static_cast<int >(wxPAPER_PENV_8)));
50882 }
50883 {
50884 PyDict_SetItemString(d,"PAPER_PENV_9", SWIG_From_int(static_cast<int >(wxPAPER_PENV_9)));
50885 }
50886 {
50887 PyDict_SetItemString(d,"PAPER_PENV_10", SWIG_From_int(static_cast<int >(wxPAPER_PENV_10)));
50888 }
50889 {
50890 PyDict_SetItemString(d,"PAPER_P16K_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P16K_ROTATED)));
50891 }
50892 {
50893 PyDict_SetItemString(d,"PAPER_P32K_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P32K_ROTATED)));
50894 }
50895 {
50896 PyDict_SetItemString(d,"PAPER_P32KBIG_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P32KBIG_ROTATED)));
50897 }
50898 {
50899 PyDict_SetItemString(d,"PAPER_PENV_1_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_1_ROTATED)));
50900 }
50901 {
50902 PyDict_SetItemString(d,"PAPER_PENV_2_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_2_ROTATED)));
50903 }
50904 {
50905 PyDict_SetItemString(d,"PAPER_PENV_3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_3_ROTATED)));
50906 }
50907 {
50908 PyDict_SetItemString(d,"PAPER_PENV_4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_4_ROTATED)));
50909 }
50910 {
50911 PyDict_SetItemString(d,"PAPER_PENV_5_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_5_ROTATED)));
50912 }
50913 {
50914 PyDict_SetItemString(d,"PAPER_PENV_6_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_6_ROTATED)));
50915 }
50916 {
50917 PyDict_SetItemString(d,"PAPER_PENV_7_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_7_ROTATED)));
50918 }
50919 {
50920 PyDict_SetItemString(d,"PAPER_PENV_8_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_8_ROTATED)));
50921 }
50922 {
50923 PyDict_SetItemString(d,"PAPER_PENV_9_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_9_ROTATED)));
50924 }
50925 {
50926 PyDict_SetItemString(d,"PAPER_PENV_10_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_10_ROTATED)));
50927 }
50928 {
50929 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int(static_cast<int >(wxDUPLEX_SIMPLEX)));
50930 }
50931 {
50932 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int(static_cast<int >(wxDUPLEX_HORIZONTAL)));
50933 }
50934 {
50935 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int(static_cast<int >(wxDUPLEX_VERTICAL)));
50936 }
50937 {
50938 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int(static_cast<int >(wxITEM_SEPARATOR)));
50939 }
50940 {
50941 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int(static_cast<int >(wxITEM_NORMAL)));
50942 }
50943 {
50944 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int(static_cast<int >(wxITEM_CHECK)));
50945 }
50946 {
50947 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int(static_cast<int >(wxITEM_RADIO)));
50948 }
50949 {
50950 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int(static_cast<int >(wxITEM_MAX)));
50951 }
50952 {
50953 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int(static_cast<int >(wxHT_NOWHERE)));
50954 }
50955 {
50956 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_FIRST)));
50957 }
50958 {
50959 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
50960 }
50961 {
50962 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
50963 }
50964 {
50965 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
50966 }
50967 {
50968 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
50969 }
50970 {
50971 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_THUMB)));
50972 }
50973 {
50974 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_BAR_1)));
50975 }
50976 {
50977 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_BAR_2)));
50978 }
50979 {
50980 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_LAST)));
50981 }
50982 {
50983 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int(static_cast<int >(wxHT_WINDOW_OUTSIDE)));
50984 }
50985 {
50986 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int(static_cast<int >(wxHT_WINDOW_INSIDE)));
50987 }
50988 {
50989 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int(static_cast<int >(wxHT_WINDOW_VERT_SCROLLBAR)));
50990 }
50991 {
50992 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int(static_cast<int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
50993 }
50994 {
50995 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int(static_cast<int >(wxHT_WINDOW_CORNER)));
50996 }
50997 {
50998 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int(static_cast<int >(wxHT_MAX)));
50999 }
51000 {
51001 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int(static_cast<int >(wxMOD_NONE)));
51002 }
51003 {
51004 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int(static_cast<int >(wxMOD_ALT)));
51005 }
51006 {
51007 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int(static_cast<int >(wxMOD_CONTROL)));
51008 }
51009 {
51010 PyDict_SetItemString(d,"MOD_ALTGR", SWIG_From_int(static_cast<int >(wxMOD_ALTGR)));
51011 }
51012 {
51013 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int(static_cast<int >(wxMOD_SHIFT)));
51014 }
51015 {
51016 PyDict_SetItemString(d,"MOD_META", SWIG_From_int(static_cast<int >(wxMOD_META)));
51017 }
51018 {
51019 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int(static_cast<int >(wxMOD_WIN)));
51020 }
51021 {
51022 PyDict_SetItemString(d,"MOD_CMD", SWIG_From_int(static_cast<int >(wxMOD_CMD)));
51023 }
51024 {
51025 PyDict_SetItemString(d,"MOD_ALL", SWIG_From_int(static_cast<int >(wxMOD_ALL)));
51026 }
51027 {
51028 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_NONE)));
51029 }
51030 {
51031 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_RECURSE)));
51032 }
51033 {
51034 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_FROMIDLE)));
51035 }
51036 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
51037 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
51038 {
51039 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_INVALID)));
51040 }
51041 {
51042 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_BMP)));
51043 }
51044 {
51045 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ICO)));
51046 }
51047 {
51048 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_CUR)));
51049 }
51050 {
51051 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XBM)));
51052 }
51053 {
51054 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XBM_DATA)));
51055 }
51056 {
51057 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XPM)));
51058 }
51059 {
51060 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XPM_DATA)));
51061 }
51062 {
51063 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_TIF)));
51064 }
51065 {
51066 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_GIF)));
51067 }
51068 {
51069 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PNG)));
51070 }
51071 {
51072 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_JPEG)));
51073 }
51074 {
51075 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PNM)));
51076 }
51077 {
51078 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PCX)));
51079 }
51080 {
51081 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PICT)));
51082 }
51083 {
51084 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ICON)));
51085 }
51086 {
51087 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ANI)));
51088 }
51089 {
51090 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_IFF)));
51091 }
51092 {
51093 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_MACCURSOR)));
51094 }
51095 {
51096 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ANY)));
51097 }
51098 {
51099 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int(static_cast<int >(wxCURSOR_NONE)));
51100 }
51101 {
51102 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_ARROW)));
51103 }
51104 {
51105 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_RIGHT_ARROW)));
51106 }
51107 {
51108 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int(static_cast<int >(wxCURSOR_BULLSEYE)));
51109 }
51110 {
51111 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int(static_cast<int >(wxCURSOR_CHAR)));
51112 }
51113 {
51114 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int(static_cast<int >(wxCURSOR_CROSS)));
51115 }
51116 {
51117 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int(static_cast<int >(wxCURSOR_HAND)));
51118 }
51119 {
51120 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int(static_cast<int >(wxCURSOR_IBEAM)));
51121 }
51122 {
51123 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_LEFT_BUTTON)));
51124 }
51125 {
51126 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int(static_cast<int >(wxCURSOR_MAGNIFIER)));
51127 }
51128 {
51129 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_MIDDLE_BUTTON)));
51130 }
51131 {
51132 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int(static_cast<int >(wxCURSOR_NO_ENTRY)));
51133 }
51134 {
51135 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int(static_cast<int >(wxCURSOR_PAINT_BRUSH)));
51136 }
51137 {
51138 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int(static_cast<int >(wxCURSOR_PENCIL)));
51139 }
51140 {
51141 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int(static_cast<int >(wxCURSOR_POINT_LEFT)));
51142 }
51143 {
51144 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int(static_cast<int >(wxCURSOR_POINT_RIGHT)));
51145 }
51146 {
51147 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_QUESTION_ARROW)));
51148 }
51149 {
51150 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_RIGHT_BUTTON)));
51151 }
51152 {
51153 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENESW)));
51154 }
51155 {
51156 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENS)));
51157 }
51158 {
51159 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENWSE)));
51160 }
51161 {
51162 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int(static_cast<int >(wxCURSOR_SIZEWE)));
51163 }
51164 {
51165 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int(static_cast<int >(wxCURSOR_SIZING)));
51166 }
51167 {
51168 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int(static_cast<int >(wxCURSOR_SPRAYCAN)));
51169 }
51170 {
51171 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int(static_cast<int >(wxCURSOR_WAIT)));
51172 }
51173 {
51174 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int(static_cast<int >(wxCURSOR_WATCH)));
51175 }
51176 {
51177 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int(static_cast<int >(wxCURSOR_BLANK)));
51178 }
51179 {
51180 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int(static_cast<int >(wxCURSOR_DEFAULT)));
51181 }
51182 {
51183 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_COPY_ARROW)));
51184 }
51185 {
51186 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int(static_cast<int >(wxCURSOR_ARROWWAIT)));
51187 }
51188 {
51189 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int(static_cast<int >(wxCURSOR_MAX)));
51190 }
51191 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
51192 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
51193 {
51194 PyDict_SetItemString(d,"FromStart", SWIG_From_int(static_cast<int >(wxFromStart)));
51195 }
51196 {
51197 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int(static_cast<int >(wxFromCurrent)));
51198 }
51199 {
51200 PyDict_SetItemString(d,"FromEnd", SWIG_From_int(static_cast<int >(wxFromEnd)));
51201 }
51202
51203 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
51204
51205
51206 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
51207
51208 {
51209 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_TRANSPARENT)));
51210 }
51211 {
51212 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_THRESHOLD)));
51213 }
51214 {
51215 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_OPAQUE)));
51216 }
51217 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
51218 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
51219 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
51220 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
51221 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
51222 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
51223 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
51224 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
51225 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
51226 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
51227 {
51228 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int(static_cast<int >(wxIMAGE_RESOLUTION_INCHES)));
51229 }
51230 {
51231 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int(static_cast<int >(wxIMAGE_RESOLUTION_CM)));
51232 }
51233 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
51234 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
51235 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
51236 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
51237 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
51238 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
51239 {
51240 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int(static_cast<int >(wxPNG_TYPE_COLOUR)));
51241 }
51242 {
51243 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int(static_cast<int >(wxPNG_TYPE_GREY)));
51244 }
51245 {
51246 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int(static_cast<int >(wxPNG_TYPE_GREY_RED)));
51247 }
51248 {
51249 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int(static_cast<int >(wxBMP_24BPP)));
51250 }
51251 {
51252 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int(static_cast<int >(wxBMP_8BPP)));
51253 }
51254 {
51255 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int(static_cast<int >(wxBMP_8BPP_GREY)));
51256 }
51257 {
51258 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int(static_cast<int >(wxBMP_8BPP_GRAY)));
51259 }
51260 {
51261 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int(static_cast<int >(wxBMP_8BPP_RED)));
51262 }
51263 {
51264 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int(static_cast<int >(wxBMP_8BPP_PALETTE)));
51265 }
51266 {
51267 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int(static_cast<int >(wxBMP_4BPP)));
51268 }
51269 {
51270 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int(static_cast<int >(wxBMP_1BPP)));
51271 }
51272 {
51273 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int(static_cast<int >(wxBMP_1BPP_BW)));
51274 }
51275 {
51276 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int(static_cast<int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
51277 }
51278 {
51279 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int(static_cast<int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
51280 }
51281 {
51282 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int(static_cast<int >(wxEVENT_PROPAGATE_NONE)));
51283 }
51284 {
51285 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int(static_cast<int >(wxEVENT_PROPAGATE_MAX)));
51286 }
51287 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
51288 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
51289 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
51290 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
51291 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
51292 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
51293 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
51294 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
51295 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
51296 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
51297 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
51298 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
51299 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
51300 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
51301 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
51302 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
51303 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
51304 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
51305 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
51306 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
51307 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
51308 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
51309 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
51310 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
51311 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
51312 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
51313 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
51314 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
51315 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
51316 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
51317 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
51318 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
51319 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
51320 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
51321 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
51322 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
51323 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
51324 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
51325 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
51326 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
51327 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
51328 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
51329 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
51330 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
51331 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
51332 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
51333 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
51334 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
51335 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
51336 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
51337 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
51338 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
51339 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
51340 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
51341 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
51342 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
51343 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
51344 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
51345 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
51346 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
51347 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
51348 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
51349 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
51350 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
51351 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
51352 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
51353 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
51354 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
51355 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
51356 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
51357 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
51358 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
51359 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
51360 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
51361 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
51362 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
51363 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
51364 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
51365 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
51366 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
51367 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
51368 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
51369 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
51370 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
51371 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
51372 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
51373 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
51374 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
51375 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
51376 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
51377 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
51378 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
51379 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
51380 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
51381 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
51382 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
51383 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
51384 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
51385 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
51386 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
51387 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
51388 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
51389 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
51390 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
51391 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
51392 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
51393 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
51394 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
51395 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
51396 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
51397 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
51398 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
51399 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
51400 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
51401 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
51402 {
51403 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_ANY)));
51404 }
51405 {
51406 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_NONE)));
51407 }
51408 {
51409 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_LEFT)));
51410 }
51411 {
51412 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_MIDDLE)));
51413 }
51414 {
51415 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_RIGHT)));
51416 }
51417 {
51418 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int(static_cast<int >(wxUPDATE_UI_PROCESS_ALL)));
51419 }
51420 {
51421 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int(static_cast<int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
51422 }
51423 {
51424 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::IsBackward)));
51425 }
51426 {
51427 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::IsForward)));
51428 }
51429 {
51430 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::WinChange)));
51431 }
51432 {
51433 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::FromTab)));
51434 }
51435 {
51436 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int(static_cast<int >(wxIDLE_PROCESS_ALL)));
51437 }
51438 {
51439 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int(static_cast<int >(wxIDLE_PROCESS_SPECIFIED)));
51440 }
51441 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
51442 {
51443 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_SUPPRESS)));
51444 }
51445 {
51446 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_EXCEPTION)));
51447 }
51448 {
51449 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_DIALOG)));
51450 }
51451 {
51452 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_LOG)));
51453 }
51454 {
51455 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int(static_cast<int >(wxPRINT_WINDOWS)));
51456 }
51457 {
51458 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int(static_cast<int >(wxPRINT_POSTSCRIPT)));
51459 }
51460 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
51461 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
51462 {
51463 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_NORMAL)));
51464 }
51465 {
51466 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_SMALL)));
51467 }
51468 {
51469 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_MINI)));
51470 }
51471 {
51472 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_LARGE)));
51473 }
51474 {
51475 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_MAX)));
51476 }
51477 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
51478 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
51479 {
51480 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_NONE)));
51481 }
51482 {
51483 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_SPECIFIED)));
51484 }
51485 {
51486 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_ALL)));
51487 }
51488 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
51489 {
51490 PyDict_SetItemString(d,"Left", SWIG_From_int(static_cast<int >(wxLeft)));
51491 }
51492 {
51493 PyDict_SetItemString(d,"Top", SWIG_From_int(static_cast<int >(wxTop)));
51494 }
51495 {
51496 PyDict_SetItemString(d,"Right", SWIG_From_int(static_cast<int >(wxRight)));
51497 }
51498 {
51499 PyDict_SetItemString(d,"Bottom", SWIG_From_int(static_cast<int >(wxBottom)));
51500 }
51501 {
51502 PyDict_SetItemString(d,"Width", SWIG_From_int(static_cast<int >(wxWidth)));
51503 }
51504 {
51505 PyDict_SetItemString(d,"Height", SWIG_From_int(static_cast<int >(wxHeight)));
51506 }
51507 {
51508 PyDict_SetItemString(d,"Centre", SWIG_From_int(static_cast<int >(wxCentre)));
51509 }
51510 {
51511 PyDict_SetItemString(d,"Center", SWIG_From_int(static_cast<int >(wxCenter)));
51512 }
51513 {
51514 PyDict_SetItemString(d,"CentreX", SWIG_From_int(static_cast<int >(wxCentreX)));
51515 }
51516 {
51517 PyDict_SetItemString(d,"CentreY", SWIG_From_int(static_cast<int >(wxCentreY)));
51518 }
51519 {
51520 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int(static_cast<int >(wxUnconstrained)));
51521 }
51522 {
51523 PyDict_SetItemString(d,"AsIs", SWIG_From_int(static_cast<int >(wxAsIs)));
51524 }
51525 {
51526 PyDict_SetItemString(d,"PercentOf", SWIG_From_int(static_cast<int >(wxPercentOf)));
51527 }
51528 {
51529 PyDict_SetItemString(d,"Above", SWIG_From_int(static_cast<int >(wxAbove)));
51530 }
51531 {
51532 PyDict_SetItemString(d,"Below", SWIG_From_int(static_cast<int >(wxBelow)));
51533 }
51534 {
51535 PyDict_SetItemString(d,"LeftOf", SWIG_From_int(static_cast<int >(wxLeftOf)));
51536 }
51537 {
51538 PyDict_SetItemString(d,"RightOf", SWIG_From_int(static_cast<int >(wxRightOf)));
51539 }
51540 {
51541 PyDict_SetItemString(d,"SameAs", SWIG_From_int(static_cast<int >(wxSameAs)));
51542 }
51543 {
51544 PyDict_SetItemString(d,"Absolute", SWIG_From_int(static_cast<int >(wxAbsolute)));
51545 }
51546
51547 // Initialize threading, some globals and such
51548 __wxPyPreStart(d);
51549
51550
51551 // Although these are defined in __version__ they need to be here too so
51552 // that an assert can be done to ensure that the wxPython and the wxWindows
51553 // versions match.
51554 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
51555 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
51556 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
51557
51558 }
51559
wxWidgets (Impactor)