]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
change doc tweaks
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.27
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #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 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\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 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\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 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\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 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\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 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
2678 #define SWIG_From_unsigned_SS_int SWIG_From_long
2679 /*@@*/
2680 #else
2681 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\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
2763 void wxApp_CleanUp() {
2764 __wxPyCleanup();
2765 }
2766
2767
2768 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2769
2770
2771 SWIGINTERNINLINE int
2772 SWIG_AsCharPtr(PyObject *obj, char **val)
2773 {
2774 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2775 return 1;
2776 }
2777 if (val) {
2778 PyErr_Clear();
2779 SWIG_type_error("char *", obj);
2780 }
2781 return 0;
2782 }
2783
2784
2785 SWIGINTERN PyObject *
2786 SWIG_FromCharPtr(const char* cptr)
2787 {
2788 if (cptr) {
2789 size_t size = strlen(cptr);
2790 if (size > INT_MAX) {
2791 return SWIG_NewPointerObj(const_cast<char* >(cptr),
2792 SWIG_TypeQuery("char *"), 0);
2793 } else {
2794 if (size != 0) {
2795 return PyString_FromStringAndSize(cptr, size);
2796 } else {
2797 return PyString_FromString(cptr);
2798 }
2799 }
2800 }
2801 Py_INCREF(Py_None);
2802 return Py_None;
2803 }
2804
2805
2806 #if 0 // #ifdef __WXMAC__
2807
2808 // A dummy class that raises an exception if used...
2809 class wxEventLoop
2810 {
2811 public:
2812 wxEventLoop() { wxPyRaiseNotImplemented(); }
2813 int Run() { return 0; }
2814 void Exit(int rc = 0) {}
2815 bool Pending() const { return false; }
2816 bool Dispatch() { return false; }
2817 bool IsRunning() const { return false; }
2818 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2819 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2820 };
2821
2822 #else
2823
2824 #include <wx/evtloop.h>
2825
2826 #endif
2827
2828
2829
2830 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2831 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2832 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2833 static PyObject *wxWindow_GetChildren(wxWindow *self){
2834 wxWindowList& list = self->GetChildren();
2835 return wxPy_ConvertList(&list);
2836 }
2837 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2838 #if wxUSE_HOTKEY
2839 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2840 #else
2841 return false;
2842 #endif
2843 }
2844 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2845
2846
2847
2848 return false;
2849
2850 }
2851 static long wxWindow_GetHandle(wxWindow *self){
2852 return wxPyGetWinHandle(self);
2853 }
2854 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2855 self->AssociateHandle((WXWidget)handle);
2856 }
2857
2858 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2859 return wxWindow::FindWindowById(id, parent);
2860 }
2861
2862 wxWindow* wxFindWindowByName( const wxString& name,
2863 const wxWindow *parent = NULL ) {
2864 return wxWindow::FindWindowByName(name, parent);
2865 }
2866
2867 wxWindow* wxFindWindowByLabel( const wxString& label,
2868 const wxWindow *parent = NULL ) {
2869 return wxWindow::FindWindowByLabel(label, parent);
2870 }
2871
2872
2873 #ifdef __WXMSW__
2874 #include <wx/msw/private.h> // to get wxGetWindowId
2875 #endif
2876
2877
2878 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2879 #ifdef __WXMSW__
2880 WXHWND hWnd = (WXHWND)_hWnd;
2881 long id = wxGetWindowId(hWnd);
2882 wxWindow* win = new wxWindow;
2883 if (parent)
2884 parent->AddChild(win);
2885 win->SetEventHandler(win);
2886 win->SetHWND(hWnd);
2887 win->SetId(id);
2888 win->SubclassWin(hWnd);
2889 win->AdoptAttributesFromHWND();
2890 win->SetupColours();
2891 return win;
2892 #else
2893 wxPyRaiseNotImplemented();
2894 return NULL;
2895 #endif
2896 }
2897
2898
2899 PyObject* GetTopLevelWindows() {
2900 return wxPy_ConvertList(&wxTopLevelWindows);
2901 }
2902
2903
2904 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2905 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2906 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2907
2908 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2909
2910 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2911 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2912 wxMenuItemList& list = self->GetMenuItems();
2913 return wxPy_ConvertList(&list);
2914 }
2915 static void wxMenuBar_SetAutoWindowMenu(bool enable){}
2916 static bool wxMenuBar_GetAutoWindowMenu(){ return false; }
2917 static const wxString wxPyControlNameStr(wxControlNameStr);
2918 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2919 if (clientData) {
2920 wxPyClientData* data = new wxPyClientData(clientData);
2921 return self->Append(item, data);
2922 } else
2923 return self->Append(item);
2924 }
2925 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2926 if (clientData) {
2927 wxPyClientData* data = new wxPyClientData(clientData);
2928 return self->Insert(item, pos, data);
2929 } else
2930 return self->Insert(item, pos);
2931 }
2932 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2933 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2934 if (data) {
2935 Py_INCREF(data->m_obj);
2936 return data->m_obj;
2937 } else {
2938 Py_INCREF(Py_None);
2939 return Py_None;
2940 }
2941 }
2942 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2943 wxPyClientData* data = new wxPyClientData(clientData);
2944 self->SetClientObject(n, data);
2945 }
2946
2947
2948 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2949 wxPyUserData* data = NULL;
2950 if ( userData ) {
2951 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2952 data = new wxPyUserData(userData);
2953 wxPyEndBlockThreads(blocked);
2954 }
2955 return new wxSizerItem(window, proportion, flag, border, data);
2956 }
2957 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2958 wxPyUserData* data = NULL;
2959 if ( userData ) {
2960 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2961 data = new wxPyUserData(userData);
2962 wxPyEndBlockThreads(blocked);
2963 }
2964 return new wxSizerItem(width, height, proportion, flag, border, data);
2965 }
2966 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2967 wxPyUserData* data = NULL;
2968 if ( userData ) {
2969 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2970 data = new wxPyUserData(userData);
2971 wxPyEndBlockThreads(blocked);
2972 }
2973 return new wxSizerItem(sizer, proportion, flag, border, data);
2974 }
2975
2976 #include <float.h>
2977 SWIGINTERN int
2978 SWIG_CheckDoubleInRange(double value, double min_value,
2979 double max_value, const char* errmsg)
2980 {
2981 if (value < min_value) {
2982 if (errmsg) {
2983 PyErr_Format(PyExc_OverflowError,
2984 "value %g is less than %s minimum %g",
2985 value, errmsg, min_value);
2986 }
2987 return 0;
2988 } else if (value > max_value) {
2989 if (errmsg) {
2990 PyErr_Format(PyExc_OverflowError,
2991 "value %g is greater than %s maximum %g",
2992 value, errmsg, max_value);
2993 }
2994 return 0;
2995 }
2996 return 1;
2997 }
2998
2999
3000 SWIGINTERN int
3001 SWIG_AsVal_float(PyObject *obj, float *val)
3002 {
3003 const char* errmsg = val ? "float" : (char*)0;
3004 double v;
3005 if (SWIG_AsVal_double(obj, &v)) {
3006 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
3007 if (val) *val = static_cast<float >(v);
3008 return 1;
3009 } else {
3010 return 0;
3011 }
3012 } else {
3013 PyErr_Clear();
3014 }
3015 if (val) {
3016 SWIG_type_error(errmsg, obj);
3017 }
3018 return 0;
3019 }
3020
3021
3022 SWIGINTERNINLINE float
3023 SWIG_As_float(PyObject* obj)
3024 {
3025 float v;
3026 if (!SWIG_AsVal_float(obj, &v)) {
3027 /*
3028 this is needed to make valgrind/purify happier.
3029 */
3030 memset((void*)&v, 0, sizeof(float));
3031 }
3032 return v;
3033 }
3034
3035
3036 SWIGINTERNINLINE int
3037 SWIG_Check_float(PyObject* obj)
3038 {
3039 return SWIG_AsVal_float(obj, (float*)0);
3040 }
3041
3042
3043 /*@c:\\PROJECTS\\SWIG-1.3.27\\Lib\\python\\pymacros.swg,72,SWIG_define@*/
3044 #define SWIG_From_float PyFloat_FromDouble
3045 /*@@*/
3046
3047 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3048 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3049 if (data) {
3050 Py_INCREF(data->m_obj);
3051 return data->m_obj;
3052 } else {
3053 Py_INCREF(Py_None);
3054 return Py_None;
3055 }
3056 }
3057 static void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3058 wxPyUserData* data = NULL;
3059 if ( userData ) {
3060 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3061 data = new wxPyUserData(userData);
3062 wxPyEndBlockThreads(blocked);
3063 }
3064 self->SetUserData(data);
3065 }
3066
3067 // Figure out the type of the sizer item
3068
3069 struct wxPySizerItemInfo {
3070 wxPySizerItemInfo()
3071 : window(NULL), sizer(NULL), gotSize(false),
3072 size(wxDefaultSize), gotPos(false), pos(-1)
3073 {}
3074
3075 wxWindow* window;
3076 wxSizer* sizer;
3077 bool gotSize;
3078 wxSize size;
3079 bool gotPos;
3080 int pos;
3081 };
3082
3083 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
3084
3085 wxPySizerItemInfo info;
3086 wxSize size;
3087 wxSize* sizePtr = &size;
3088
3089 // Find out what the type of the item is
3090 // try wxWindow
3091 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
3092 PyErr_Clear();
3093 info.window = NULL;
3094
3095 // try wxSizer
3096 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
3097 PyErr_Clear();
3098 info.sizer = NULL;
3099
3100 // try wxSize or (w,h)
3101 if ( checkSize && wxSize_helper(item, &sizePtr)) {
3102 info.size = *sizePtr;
3103 info.gotSize = true;
3104 }
3105
3106 // or a single int
3107 if (checkIdx && PyInt_Check(item)) {
3108 info.pos = PyInt_AsLong(item);
3109 info.gotPos = true;
3110 }
3111 }
3112 }
3113
3114 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3115 // no expected type, figure out what kind of error message to generate
3116 if ( !checkSize && !checkIdx )
3117 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3118 else if ( checkSize && !checkIdx )
3119 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3120 else if ( !checkSize && checkIdx)
3121 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3122 else
3123 // can this one happen?
3124 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3125 }
3126
3127 return info;
3128 }
3129
3130 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3131 if (!self->GetClientObject())
3132 self->SetClientObject(new wxPyOORClientData(_self));
3133 }
3134 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3135
3136 wxPyUserData* data = NULL;
3137 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3138 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3139 if ( userData && (info.window || info.sizer || info.gotSize) )
3140 data = new wxPyUserData(userData);
3141 if ( info.sizer )
3142 PyObject_SetAttrString(item,"thisown",Py_False);
3143 wxPyEndBlockThreads(blocked);
3144
3145 // Now call the real Add method if a valid item type was found
3146 if ( info.window )
3147 return self->Add(info.window, proportion, flag, border, data);
3148 else if ( info.sizer )
3149 return self->Add(info.sizer, proportion, flag, border, data);
3150 else if (info.gotSize)
3151 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3152 proportion, flag, border, data);
3153 else
3154 return NULL;
3155 }
3156 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3157
3158 wxPyUserData* data = NULL;
3159 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3160 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3161 if ( userData && (info.window || info.sizer || info.gotSize) )
3162 data = new wxPyUserData(userData);
3163 if ( info.sizer )
3164 PyObject_SetAttrString(item,"thisown",Py_False);
3165 wxPyEndBlockThreads(blocked);
3166
3167 // Now call the real Insert method if a valid item type was found
3168 if ( info.window )
3169 return self->Insert(before, info.window, proportion, flag, border, data);
3170 else if ( info.sizer )
3171 return self->Insert(before, info.sizer, proportion, flag, border, data);
3172 else if (info.gotSize)
3173 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3174 proportion, flag, border, data);
3175 else
3176 return NULL;
3177 }
3178 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3179
3180 wxPyUserData* data = NULL;
3181 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3182 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3183 if ( userData && (info.window || info.sizer || info.gotSize) )
3184 data = new wxPyUserData(userData);
3185 if ( info.sizer )
3186 PyObject_SetAttrString(item,"thisown",Py_False);
3187 wxPyEndBlockThreads(blocked);
3188
3189 // Now call the real Prepend method if a valid item type was found
3190 if ( info.window )
3191 return self->Prepend(info.window, proportion, flag, border, data);
3192 else if ( info.sizer )
3193 return self->Prepend(info.sizer, proportion, flag, border, data);
3194 else if (info.gotSize)
3195 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3196 proportion, flag, border, data);
3197 else
3198 return NULL;
3199 }
3200 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3201 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3202 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3203 wxPyEndBlockThreads(blocked);
3204 if ( info.window )
3205 return self->Remove(info.window);
3206 else if ( info.sizer )
3207 return self->Remove(info.sizer);
3208 else if ( info.gotPos )
3209 return self->Remove(info.pos);
3210 else
3211 return false;
3212 }
3213 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3214 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3215 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3216 wxPyEndBlockThreads(blocked);
3217 if ( info.window )
3218 return self->Detach(info.window);
3219 else if ( info.sizer )
3220 return self->Detach(info.sizer);
3221 else if ( info.gotPos )
3222 return self->Detach(info.pos);
3223 else
3224 return false;
3225 }
3226 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3227 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3228 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3229 wxPyEndBlockThreads(blocked);
3230 if ( info.window )
3231 return self->GetItem(info.window);
3232 else if ( info.sizer )
3233 return self->GetItem(info.sizer);
3234 else if ( info.gotPos )
3235 return self->GetItem(info.pos);
3236 else
3237 return NULL;
3238 }
3239 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3240 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3241 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3242 wxPyEndBlockThreads(blocked);
3243 if ( info.window )
3244 self->SetItemMinSize(info.window, size);
3245 else if ( info.sizer )
3246 self->SetItemMinSize(info.sizer, size);
3247 else if ( info.gotPos )
3248 self->SetItemMinSize(info.pos, size);
3249 }
3250 static PyObject *wxSizer_GetChildren(wxSizer *self){
3251 wxSizerItemList& list = self->GetChildren();
3252 return wxPy_ConvertList(&list);
3253 }
3254 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3255 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3256 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3257 wxPyEndBlockThreads(blocked);
3258 if ( info.window )
3259 return self->Show(info.window, show, recursive);
3260 else if ( info.sizer )
3261 return self->Show(info.sizer, show, recursive);
3262 else if ( info.gotPos )
3263 return self->Show(info.pos, show);
3264 else
3265 return false;
3266 }
3267 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3268 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3269 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3270 wxPyEndBlockThreads(blocked);
3271 if ( info.window )
3272 return self->IsShown(info.window);
3273 else if ( info.sizer )
3274 return self->IsShown(info.sizer);
3275 else if ( info.gotPos )
3276 return self->IsShown(info.pos);
3277 else
3278 return false;
3279 }
3280
3281 // See pyclasses.h
3282 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3283 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3284 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3285
3286
3287
3288
3289 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3290 {
3291 if (source == Py_None) {
3292 **obj = wxGBPosition(-1,-1);
3293 return true;
3294 }
3295 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3296 }
3297
3298 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3299 {
3300 if (source == Py_None) {
3301 **obj = wxGBSpan(-1,-1);
3302 return true;
3303 }
3304 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3305 }
3306
3307
3308 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3309 self->SetRow(row);
3310 self->SetCol(col);
3311 }
3312 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3313 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3314 PyObject* tup = PyTuple_New(2);
3315 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3316 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3317 wxPyEndBlockThreads(blocked);
3318 return tup;
3319 }
3320 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3321 self->SetRowspan(rowspan);
3322 self->SetColspan(colspan);
3323 }
3324 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3325 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3326 PyObject* tup = PyTuple_New(2);
3327 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3328 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3329 wxPyEndBlockThreads(blocked);
3330 return tup;
3331 }
3332 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3333 wxPyUserData* data = NULL;
3334 if ( userData ) {
3335 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3336 data = new wxPyUserData(userData);
3337 wxPyEndBlockThreads(blocked);
3338 }
3339 return new wxGBSizerItem(window, pos, span, flag, border, data);
3340 }
3341 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3342 wxPyUserData* data = NULL;
3343 if ( userData ) {
3344 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3345 data = new wxPyUserData(userData);
3346 wxPyEndBlockThreads(blocked);
3347 }
3348 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3349 }
3350 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3351 wxPyUserData* data = NULL;
3352 if ( userData ) {
3353 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3354 data = new wxPyUserData(userData);
3355 wxPyEndBlockThreads(blocked);
3356 }
3357 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3358 }
3359 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3360 int row, col;
3361 self->GetEndPos(row, col);
3362 return wxGBPosition(row, col);
3363 }
3364 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3365
3366 wxPyUserData* data = NULL;
3367 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3368 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3369 if ( userData && (info.window || info.sizer || info.gotSize) )
3370 data = new wxPyUserData(userData);
3371 if ( info.sizer )
3372 PyObject_SetAttrString(item,"thisown",Py_False);
3373 wxPyEndBlockThreads(blocked);
3374
3375 // Now call the real Add method if a valid item type was found
3376 if ( info.window )
3377 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3378 else if ( info.sizer )
3379 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3380 else if (info.gotSize)
3381 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3382 pos, span, flag, border, data);
3383 return NULL;
3384 }
3385
3386
3387 #ifdef __cplusplus
3388 extern "C" {
3389 #endif
3390 static int _wrap_EmptyString_set(PyObject *) {
3391 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3392 return 1;
3393 }
3394
3395
3396 static PyObject *_wrap_EmptyString_get(void) {
3397 PyObject *pyobj = NULL;
3398
3399 {
3400 #if wxUSE_UNICODE
3401 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3402 #else
3403 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3404 #endif
3405 }
3406 return pyobj;
3407 }
3408
3409
3410 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3411 PyObject *resultobj = NULL;
3412 wxObject *arg1 = (wxObject *) 0 ;
3413 wxString result;
3414 PyObject * obj0 = 0 ;
3415 char *kwnames[] = {
3416 (char *) "self", NULL
3417 };
3418
3419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3421 if (SWIG_arg_fail(1)) SWIG_fail;
3422 {
3423 PyThreadState* __tstate = wxPyBeginAllowThreads();
3424 result = wxObject_GetClassName(arg1);
3425
3426 wxPyEndAllowThreads(__tstate);
3427 if (PyErr_Occurred()) SWIG_fail;
3428 }
3429 {
3430 #if wxUSE_UNICODE
3431 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3432 #else
3433 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3434 #endif
3435 }
3436 return resultobj;
3437 fail:
3438 return NULL;
3439 }
3440
3441
3442 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3443 PyObject *resultobj = NULL;
3444 wxObject *arg1 = (wxObject *) 0 ;
3445 PyObject * obj0 = 0 ;
3446 char *kwnames[] = {
3447 (char *) "self", NULL
3448 };
3449
3450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3452 if (SWIG_arg_fail(1)) SWIG_fail;
3453 {
3454 PyThreadState* __tstate = wxPyBeginAllowThreads();
3455 wxObject_Destroy(arg1);
3456
3457 wxPyEndAllowThreads(__tstate);
3458 if (PyErr_Occurred()) SWIG_fail;
3459 }
3460 Py_INCREF(Py_None); resultobj = Py_None;
3461 return resultobj;
3462 fail:
3463 return NULL;
3464 }
3465
3466
3467 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3468 PyObject *obj;
3469 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3470 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3471 Py_INCREF(obj);
3472 return Py_BuildValue((char *)"");
3473 }
3474 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3475 PyObject *resultobj = NULL;
3476 wxSize *arg1 = (wxSize *) 0 ;
3477 int arg2 ;
3478 PyObject * obj0 = 0 ;
3479 PyObject * obj1 = 0 ;
3480 char *kwnames[] = {
3481 (char *) "self",(char *) "x", NULL
3482 };
3483
3484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3486 if (SWIG_arg_fail(1)) SWIG_fail;
3487 {
3488 arg2 = static_cast<int >(SWIG_As_int(obj1));
3489 if (SWIG_arg_fail(2)) SWIG_fail;
3490 }
3491 if (arg1) (arg1)->x = arg2;
3492
3493 Py_INCREF(Py_None); resultobj = Py_None;
3494 return resultobj;
3495 fail:
3496 return NULL;
3497 }
3498
3499
3500 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3501 PyObject *resultobj = NULL;
3502 wxSize *arg1 = (wxSize *) 0 ;
3503 int result;
3504 PyObject * obj0 = 0 ;
3505 char *kwnames[] = {
3506 (char *) "self", NULL
3507 };
3508
3509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3511 if (SWIG_arg_fail(1)) SWIG_fail;
3512 result = (int) ((arg1)->x);
3513
3514 {
3515 resultobj = SWIG_From_int(static_cast<int >(result));
3516 }
3517 return resultobj;
3518 fail:
3519 return NULL;
3520 }
3521
3522
3523 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3524 PyObject *resultobj = NULL;
3525 wxSize *arg1 = (wxSize *) 0 ;
3526 int arg2 ;
3527 PyObject * obj0 = 0 ;
3528 PyObject * obj1 = 0 ;
3529 char *kwnames[] = {
3530 (char *) "self",(char *) "y", NULL
3531 };
3532
3533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3535 if (SWIG_arg_fail(1)) SWIG_fail;
3536 {
3537 arg2 = static_cast<int >(SWIG_As_int(obj1));
3538 if (SWIG_arg_fail(2)) SWIG_fail;
3539 }
3540 if (arg1) (arg1)->y = arg2;
3541
3542 Py_INCREF(Py_None); resultobj = Py_None;
3543 return resultobj;
3544 fail:
3545 return NULL;
3546 }
3547
3548
3549 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3550 PyObject *resultobj = NULL;
3551 wxSize *arg1 = (wxSize *) 0 ;
3552 int result;
3553 PyObject * obj0 = 0 ;
3554 char *kwnames[] = {
3555 (char *) "self", NULL
3556 };
3557
3558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3560 if (SWIG_arg_fail(1)) SWIG_fail;
3561 result = (int) ((arg1)->y);
3562
3563 {
3564 resultobj = SWIG_From_int(static_cast<int >(result));
3565 }
3566 return resultobj;
3567 fail:
3568 return NULL;
3569 }
3570
3571
3572 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3573 PyObject *resultobj = NULL;
3574 int arg1 = (int) 0 ;
3575 int arg2 = (int) 0 ;
3576 wxSize *result;
3577 PyObject * obj0 = 0 ;
3578 PyObject * obj1 = 0 ;
3579 char *kwnames[] = {
3580 (char *) "w",(char *) "h", NULL
3581 };
3582
3583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3584 if (obj0) {
3585 {
3586 arg1 = static_cast<int >(SWIG_As_int(obj0));
3587 if (SWIG_arg_fail(1)) SWIG_fail;
3588 }
3589 }
3590 if (obj1) {
3591 {
3592 arg2 = static_cast<int >(SWIG_As_int(obj1));
3593 if (SWIG_arg_fail(2)) SWIG_fail;
3594 }
3595 }
3596 {
3597 PyThreadState* __tstate = wxPyBeginAllowThreads();
3598 result = (wxSize *)new wxSize(arg1,arg2);
3599
3600 wxPyEndAllowThreads(__tstate);
3601 if (PyErr_Occurred()) SWIG_fail;
3602 }
3603 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3604 return resultobj;
3605 fail:
3606 return NULL;
3607 }
3608
3609
3610 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3611 PyObject *resultobj = NULL;
3612 wxSize *arg1 = (wxSize *) 0 ;
3613 PyObject * obj0 = 0 ;
3614 char *kwnames[] = {
3615 (char *) "self", NULL
3616 };
3617
3618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3620 if (SWIG_arg_fail(1)) SWIG_fail;
3621 {
3622 PyThreadState* __tstate = wxPyBeginAllowThreads();
3623 delete arg1;
3624
3625 wxPyEndAllowThreads(__tstate);
3626 if (PyErr_Occurred()) SWIG_fail;
3627 }
3628 Py_INCREF(Py_None); resultobj = Py_None;
3629 return resultobj;
3630 fail:
3631 return NULL;
3632 }
3633
3634
3635 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3636 PyObject *resultobj = NULL;
3637 wxSize *arg1 = (wxSize *) 0 ;
3638 wxSize *arg2 = 0 ;
3639 bool result;
3640 wxSize temp2 ;
3641 PyObject * obj0 = 0 ;
3642 PyObject * obj1 = 0 ;
3643 char *kwnames[] = {
3644 (char *) "self",(char *) "sz", NULL
3645 };
3646
3647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3649 if (SWIG_arg_fail(1)) SWIG_fail;
3650 {
3651 arg2 = &temp2;
3652 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3653 }
3654 {
3655 PyThreadState* __tstate = wxPyBeginAllowThreads();
3656 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3657
3658 wxPyEndAllowThreads(__tstate);
3659 if (PyErr_Occurred()) SWIG_fail;
3660 }
3661 {
3662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3663 }
3664 return resultobj;
3665 fail:
3666 return NULL;
3667 }
3668
3669
3670 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3671 PyObject *resultobj = NULL;
3672 wxSize *arg1 = (wxSize *) 0 ;
3673 wxSize *arg2 = 0 ;
3674 bool result;
3675 wxSize temp2 ;
3676 PyObject * obj0 = 0 ;
3677 PyObject * obj1 = 0 ;
3678 char *kwnames[] = {
3679 (char *) "self",(char *) "sz", NULL
3680 };
3681
3682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3684 if (SWIG_arg_fail(1)) SWIG_fail;
3685 {
3686 arg2 = &temp2;
3687 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3688 }
3689 {
3690 PyThreadState* __tstate = wxPyBeginAllowThreads();
3691 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3692
3693 wxPyEndAllowThreads(__tstate);
3694 if (PyErr_Occurred()) SWIG_fail;
3695 }
3696 {
3697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3698 }
3699 return resultobj;
3700 fail:
3701 return NULL;
3702 }
3703
3704
3705 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3706 PyObject *resultobj = NULL;
3707 wxSize *arg1 = (wxSize *) 0 ;
3708 wxSize *arg2 = 0 ;
3709 wxSize result;
3710 wxSize temp2 ;
3711 PyObject * obj0 = 0 ;
3712 PyObject * obj1 = 0 ;
3713 char *kwnames[] = {
3714 (char *) "self",(char *) "sz", NULL
3715 };
3716
3717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3719 if (SWIG_arg_fail(1)) SWIG_fail;
3720 {
3721 arg2 = &temp2;
3722 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3723 }
3724 {
3725 PyThreadState* __tstate = wxPyBeginAllowThreads();
3726 result = (arg1)->operator +((wxSize const &)*arg2);
3727
3728 wxPyEndAllowThreads(__tstate);
3729 if (PyErr_Occurred()) SWIG_fail;
3730 }
3731 {
3732 wxSize * resultptr;
3733 resultptr = new wxSize(static_cast<wxSize & >(result));
3734 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3735 }
3736 return resultobj;
3737 fail:
3738 return NULL;
3739 }
3740
3741
3742 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3743 PyObject *resultobj = NULL;
3744 wxSize *arg1 = (wxSize *) 0 ;
3745 wxSize *arg2 = 0 ;
3746 wxSize result;
3747 wxSize temp2 ;
3748 PyObject * obj0 = 0 ;
3749 PyObject * obj1 = 0 ;
3750 char *kwnames[] = {
3751 (char *) "self",(char *) "sz", NULL
3752 };
3753
3754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3756 if (SWIG_arg_fail(1)) SWIG_fail;
3757 {
3758 arg2 = &temp2;
3759 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3760 }
3761 {
3762 PyThreadState* __tstate = wxPyBeginAllowThreads();
3763 result = (arg1)->operator -((wxSize const &)*arg2);
3764
3765 wxPyEndAllowThreads(__tstate);
3766 if (PyErr_Occurred()) SWIG_fail;
3767 }
3768 {
3769 wxSize * resultptr;
3770 resultptr = new wxSize(static_cast<wxSize & >(result));
3771 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3772 }
3773 return resultobj;
3774 fail:
3775 return NULL;
3776 }
3777
3778
3779 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3780 PyObject *resultobj = NULL;
3781 wxSize *arg1 = (wxSize *) 0 ;
3782 wxSize *arg2 = 0 ;
3783 wxSize temp2 ;
3784 PyObject * obj0 = 0 ;
3785 PyObject * obj1 = 0 ;
3786 char *kwnames[] = {
3787 (char *) "self",(char *) "sz", NULL
3788 };
3789
3790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3792 if (SWIG_arg_fail(1)) SWIG_fail;
3793 {
3794 arg2 = &temp2;
3795 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3796 }
3797 {
3798 PyThreadState* __tstate = wxPyBeginAllowThreads();
3799 (arg1)->IncTo((wxSize const &)*arg2);
3800
3801 wxPyEndAllowThreads(__tstate);
3802 if (PyErr_Occurred()) SWIG_fail;
3803 }
3804 Py_INCREF(Py_None); resultobj = Py_None;
3805 return resultobj;
3806 fail:
3807 return NULL;
3808 }
3809
3810
3811 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3812 PyObject *resultobj = NULL;
3813 wxSize *arg1 = (wxSize *) 0 ;
3814 wxSize *arg2 = 0 ;
3815 wxSize temp2 ;
3816 PyObject * obj0 = 0 ;
3817 PyObject * obj1 = 0 ;
3818 char *kwnames[] = {
3819 (char *) "self",(char *) "sz", NULL
3820 };
3821
3822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3824 if (SWIG_arg_fail(1)) SWIG_fail;
3825 {
3826 arg2 = &temp2;
3827 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3828 }
3829 {
3830 PyThreadState* __tstate = wxPyBeginAllowThreads();
3831 (arg1)->DecTo((wxSize const &)*arg2);
3832
3833 wxPyEndAllowThreads(__tstate);
3834 if (PyErr_Occurred()) SWIG_fail;
3835 }
3836 Py_INCREF(Py_None); resultobj = Py_None;
3837 return resultobj;
3838 fail:
3839 return NULL;
3840 }
3841
3842
3843 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3844 PyObject *resultobj = NULL;
3845 wxSize *arg1 = (wxSize *) 0 ;
3846 int arg2 ;
3847 int arg3 ;
3848 PyObject * obj0 = 0 ;
3849 PyObject * obj1 = 0 ;
3850 PyObject * obj2 = 0 ;
3851 char *kwnames[] = {
3852 (char *) "self",(char *) "w",(char *) "h", NULL
3853 };
3854
3855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3857 if (SWIG_arg_fail(1)) SWIG_fail;
3858 {
3859 arg2 = static_cast<int >(SWIG_As_int(obj1));
3860 if (SWIG_arg_fail(2)) SWIG_fail;
3861 }
3862 {
3863 arg3 = static_cast<int >(SWIG_As_int(obj2));
3864 if (SWIG_arg_fail(3)) SWIG_fail;
3865 }
3866 {
3867 PyThreadState* __tstate = wxPyBeginAllowThreads();
3868 (arg1)->Set(arg2,arg3);
3869
3870 wxPyEndAllowThreads(__tstate);
3871 if (PyErr_Occurred()) SWIG_fail;
3872 }
3873 Py_INCREF(Py_None); resultobj = Py_None;
3874 return resultobj;
3875 fail:
3876 return NULL;
3877 }
3878
3879
3880 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3881 PyObject *resultobj = NULL;
3882 wxSize *arg1 = (wxSize *) 0 ;
3883 int arg2 ;
3884 PyObject * obj0 = 0 ;
3885 PyObject * obj1 = 0 ;
3886 char *kwnames[] = {
3887 (char *) "self",(char *) "w", NULL
3888 };
3889
3890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3892 if (SWIG_arg_fail(1)) SWIG_fail;
3893 {
3894 arg2 = static_cast<int >(SWIG_As_int(obj1));
3895 if (SWIG_arg_fail(2)) SWIG_fail;
3896 }
3897 {
3898 PyThreadState* __tstate = wxPyBeginAllowThreads();
3899 (arg1)->SetWidth(arg2);
3900
3901 wxPyEndAllowThreads(__tstate);
3902 if (PyErr_Occurred()) SWIG_fail;
3903 }
3904 Py_INCREF(Py_None); resultobj = Py_None;
3905 return resultobj;
3906 fail:
3907 return NULL;
3908 }
3909
3910
3911 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3912 PyObject *resultobj = NULL;
3913 wxSize *arg1 = (wxSize *) 0 ;
3914 int arg2 ;
3915 PyObject * obj0 = 0 ;
3916 PyObject * obj1 = 0 ;
3917 char *kwnames[] = {
3918 (char *) "self",(char *) "h", NULL
3919 };
3920
3921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3923 if (SWIG_arg_fail(1)) SWIG_fail;
3924 {
3925 arg2 = static_cast<int >(SWIG_As_int(obj1));
3926 if (SWIG_arg_fail(2)) SWIG_fail;
3927 }
3928 {
3929 PyThreadState* __tstate = wxPyBeginAllowThreads();
3930 (arg1)->SetHeight(arg2);
3931
3932 wxPyEndAllowThreads(__tstate);
3933 if (PyErr_Occurred()) SWIG_fail;
3934 }
3935 Py_INCREF(Py_None); resultobj = Py_None;
3936 return resultobj;
3937 fail:
3938 return NULL;
3939 }
3940
3941
3942 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3943 PyObject *resultobj = NULL;
3944 wxSize *arg1 = (wxSize *) 0 ;
3945 int result;
3946 PyObject * obj0 = 0 ;
3947 char *kwnames[] = {
3948 (char *) "self", NULL
3949 };
3950
3951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3953 if (SWIG_arg_fail(1)) SWIG_fail;
3954 {
3955 PyThreadState* __tstate = wxPyBeginAllowThreads();
3956 result = (int)((wxSize const *)arg1)->GetWidth();
3957
3958 wxPyEndAllowThreads(__tstate);
3959 if (PyErr_Occurred()) SWIG_fail;
3960 }
3961 {
3962 resultobj = SWIG_From_int(static_cast<int >(result));
3963 }
3964 return resultobj;
3965 fail:
3966 return NULL;
3967 }
3968
3969
3970 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3971 PyObject *resultobj = NULL;
3972 wxSize *arg1 = (wxSize *) 0 ;
3973 int result;
3974 PyObject * obj0 = 0 ;
3975 char *kwnames[] = {
3976 (char *) "self", NULL
3977 };
3978
3979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3981 if (SWIG_arg_fail(1)) SWIG_fail;
3982 {
3983 PyThreadState* __tstate = wxPyBeginAllowThreads();
3984 result = (int)((wxSize const *)arg1)->GetHeight();
3985
3986 wxPyEndAllowThreads(__tstate);
3987 if (PyErr_Occurred()) SWIG_fail;
3988 }
3989 {
3990 resultobj = SWIG_From_int(static_cast<int >(result));
3991 }
3992 return resultobj;
3993 fail:
3994 return NULL;
3995 }
3996
3997
3998 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3999 PyObject *resultobj = NULL;
4000 wxSize *arg1 = (wxSize *) 0 ;
4001 bool result;
4002 PyObject * obj0 = 0 ;
4003 char *kwnames[] = {
4004 (char *) "self", NULL
4005 };
4006
4007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
4008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4009 if (SWIG_arg_fail(1)) SWIG_fail;
4010 {
4011 PyThreadState* __tstate = wxPyBeginAllowThreads();
4012 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
4013
4014 wxPyEndAllowThreads(__tstate);
4015 if (PyErr_Occurred()) SWIG_fail;
4016 }
4017 {
4018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4019 }
4020 return resultobj;
4021 fail:
4022 return NULL;
4023 }
4024
4025
4026 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
4027 PyObject *resultobj = NULL;
4028 wxSize *arg1 = (wxSize *) 0 ;
4029 wxSize *arg2 = 0 ;
4030 wxSize temp2 ;
4031 PyObject * obj0 = 0 ;
4032 PyObject * obj1 = 0 ;
4033 char *kwnames[] = {
4034 (char *) "self",(char *) "size", NULL
4035 };
4036
4037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
4038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4039 if (SWIG_arg_fail(1)) SWIG_fail;
4040 {
4041 arg2 = &temp2;
4042 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4043 }
4044 {
4045 PyThreadState* __tstate = wxPyBeginAllowThreads();
4046 (arg1)->SetDefaults((wxSize const &)*arg2);
4047
4048 wxPyEndAllowThreads(__tstate);
4049 if (PyErr_Occurred()) SWIG_fail;
4050 }
4051 Py_INCREF(Py_None); resultobj = Py_None;
4052 return resultobj;
4053 fail:
4054 return NULL;
4055 }
4056
4057
4058 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4059 PyObject *resultobj = NULL;
4060 wxSize *arg1 = (wxSize *) 0 ;
4061 PyObject *result;
4062 PyObject * obj0 = 0 ;
4063 char *kwnames[] = {
4064 (char *) "self", NULL
4065 };
4066
4067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
4068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
4069 if (SWIG_arg_fail(1)) SWIG_fail;
4070 {
4071 PyThreadState* __tstate = wxPyBeginAllowThreads();
4072 result = (PyObject *)wxSize_Get(arg1);
4073
4074 wxPyEndAllowThreads(__tstate);
4075 if (PyErr_Occurred()) SWIG_fail;
4076 }
4077 resultobj = result;
4078 return resultobj;
4079 fail:
4080 return NULL;
4081 }
4082
4083
4084 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
4085 PyObject *obj;
4086 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4087 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
4088 Py_INCREF(obj);
4089 return Py_BuildValue((char *)"");
4090 }
4091 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4092 PyObject *resultobj = NULL;
4093 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4094 double arg2 ;
4095 PyObject * obj0 = 0 ;
4096 PyObject * obj1 = 0 ;
4097 char *kwnames[] = {
4098 (char *) "self",(char *) "x", NULL
4099 };
4100
4101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
4102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4103 if (SWIG_arg_fail(1)) SWIG_fail;
4104 {
4105 arg2 = static_cast<double >(SWIG_As_double(obj1));
4106 if (SWIG_arg_fail(2)) SWIG_fail;
4107 }
4108 if (arg1) (arg1)->x = arg2;
4109
4110 Py_INCREF(Py_None); resultobj = Py_None;
4111 return resultobj;
4112 fail:
4113 return NULL;
4114 }
4115
4116
4117 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4118 PyObject *resultobj = NULL;
4119 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4120 double result;
4121 PyObject * obj0 = 0 ;
4122 char *kwnames[] = {
4123 (char *) "self", NULL
4124 };
4125
4126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
4127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4128 if (SWIG_arg_fail(1)) SWIG_fail;
4129 result = (double) ((arg1)->x);
4130
4131 {
4132 resultobj = SWIG_From_double(static_cast<double >(result));
4133 }
4134 return resultobj;
4135 fail:
4136 return NULL;
4137 }
4138
4139
4140 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4141 PyObject *resultobj = NULL;
4142 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4143 double arg2 ;
4144 PyObject * obj0 = 0 ;
4145 PyObject * obj1 = 0 ;
4146 char *kwnames[] = {
4147 (char *) "self",(char *) "y", NULL
4148 };
4149
4150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4152 if (SWIG_arg_fail(1)) SWIG_fail;
4153 {
4154 arg2 = static_cast<double >(SWIG_As_double(obj1));
4155 if (SWIG_arg_fail(2)) SWIG_fail;
4156 }
4157 if (arg1) (arg1)->y = arg2;
4158
4159 Py_INCREF(Py_None); resultobj = Py_None;
4160 return resultobj;
4161 fail:
4162 return NULL;
4163 }
4164
4165
4166 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4167 PyObject *resultobj = NULL;
4168 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4169 double result;
4170 PyObject * obj0 = 0 ;
4171 char *kwnames[] = {
4172 (char *) "self", NULL
4173 };
4174
4175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4177 if (SWIG_arg_fail(1)) SWIG_fail;
4178 result = (double) ((arg1)->y);
4179
4180 {
4181 resultobj = SWIG_From_double(static_cast<double >(result));
4182 }
4183 return resultobj;
4184 fail:
4185 return NULL;
4186 }
4187
4188
4189 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4190 PyObject *resultobj = NULL;
4191 double arg1 = (double) 0.0 ;
4192 double arg2 = (double) 0.0 ;
4193 wxRealPoint *result;
4194 PyObject * obj0 = 0 ;
4195 PyObject * obj1 = 0 ;
4196 char *kwnames[] = {
4197 (char *) "x",(char *) "y", NULL
4198 };
4199
4200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4201 if (obj0) {
4202 {
4203 arg1 = static_cast<double >(SWIG_As_double(obj0));
4204 if (SWIG_arg_fail(1)) SWIG_fail;
4205 }
4206 }
4207 if (obj1) {
4208 {
4209 arg2 = static_cast<double >(SWIG_As_double(obj1));
4210 if (SWIG_arg_fail(2)) SWIG_fail;
4211 }
4212 }
4213 {
4214 PyThreadState* __tstate = wxPyBeginAllowThreads();
4215 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4216
4217 wxPyEndAllowThreads(__tstate);
4218 if (PyErr_Occurred()) SWIG_fail;
4219 }
4220 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4221 return resultobj;
4222 fail:
4223 return NULL;
4224 }
4225
4226
4227 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4228 PyObject *resultobj = NULL;
4229 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4230 PyObject * obj0 = 0 ;
4231 char *kwnames[] = {
4232 (char *) "self", NULL
4233 };
4234
4235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4237 if (SWIG_arg_fail(1)) SWIG_fail;
4238 {
4239 PyThreadState* __tstate = wxPyBeginAllowThreads();
4240 delete arg1;
4241
4242 wxPyEndAllowThreads(__tstate);
4243 if (PyErr_Occurred()) SWIG_fail;
4244 }
4245 Py_INCREF(Py_None); resultobj = Py_None;
4246 return resultobj;
4247 fail:
4248 return NULL;
4249 }
4250
4251
4252 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4253 PyObject *resultobj = NULL;
4254 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4255 wxRealPoint *arg2 = 0 ;
4256 bool result;
4257 wxRealPoint temp2 ;
4258 PyObject * obj0 = 0 ;
4259 PyObject * obj1 = 0 ;
4260 char *kwnames[] = {
4261 (char *) "self",(char *) "pt", NULL
4262 };
4263
4264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4266 if (SWIG_arg_fail(1)) SWIG_fail;
4267 {
4268 arg2 = &temp2;
4269 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4270 }
4271 {
4272 PyThreadState* __tstate = wxPyBeginAllowThreads();
4273 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4274
4275 wxPyEndAllowThreads(__tstate);
4276 if (PyErr_Occurred()) SWIG_fail;
4277 }
4278 {
4279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4280 }
4281 return resultobj;
4282 fail:
4283 return NULL;
4284 }
4285
4286
4287 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4288 PyObject *resultobj = NULL;
4289 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4290 wxRealPoint *arg2 = 0 ;
4291 bool result;
4292 wxRealPoint temp2 ;
4293 PyObject * obj0 = 0 ;
4294 PyObject * obj1 = 0 ;
4295 char *kwnames[] = {
4296 (char *) "self",(char *) "pt", NULL
4297 };
4298
4299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4301 if (SWIG_arg_fail(1)) SWIG_fail;
4302 {
4303 arg2 = &temp2;
4304 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4305 }
4306 {
4307 PyThreadState* __tstate = wxPyBeginAllowThreads();
4308 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4309
4310 wxPyEndAllowThreads(__tstate);
4311 if (PyErr_Occurred()) SWIG_fail;
4312 }
4313 {
4314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4315 }
4316 return resultobj;
4317 fail:
4318 return NULL;
4319 }
4320
4321
4322 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4323 PyObject *resultobj = NULL;
4324 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4325 wxRealPoint *arg2 = 0 ;
4326 wxRealPoint result;
4327 wxRealPoint temp2 ;
4328 PyObject * obj0 = 0 ;
4329 PyObject * obj1 = 0 ;
4330 char *kwnames[] = {
4331 (char *) "self",(char *) "pt", NULL
4332 };
4333
4334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4336 if (SWIG_arg_fail(1)) SWIG_fail;
4337 {
4338 arg2 = &temp2;
4339 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4340 }
4341 {
4342 PyThreadState* __tstate = wxPyBeginAllowThreads();
4343 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4344
4345 wxPyEndAllowThreads(__tstate);
4346 if (PyErr_Occurred()) SWIG_fail;
4347 }
4348 {
4349 wxRealPoint * resultptr;
4350 resultptr = new wxRealPoint(static_cast<wxRealPoint & >(result));
4351 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4352 }
4353 return resultobj;
4354 fail:
4355 return NULL;
4356 }
4357
4358
4359 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4360 PyObject *resultobj = NULL;
4361 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4362 wxRealPoint *arg2 = 0 ;
4363 wxRealPoint result;
4364 wxRealPoint temp2 ;
4365 PyObject * obj0 = 0 ;
4366 PyObject * obj1 = 0 ;
4367 char *kwnames[] = {
4368 (char *) "self",(char *) "pt", NULL
4369 };
4370
4371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4373 if (SWIG_arg_fail(1)) SWIG_fail;
4374 {
4375 arg2 = &temp2;
4376 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4377 }
4378 {
4379 PyThreadState* __tstate = wxPyBeginAllowThreads();
4380 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4381
4382 wxPyEndAllowThreads(__tstate);
4383 if (PyErr_Occurred()) SWIG_fail;
4384 }
4385 {
4386 wxRealPoint * resultptr;
4387 resultptr = new wxRealPoint(static_cast<wxRealPoint & >(result));
4388 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4389 }
4390 return resultobj;
4391 fail:
4392 return NULL;
4393 }
4394
4395
4396 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4397 PyObject *resultobj = NULL;
4398 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4399 double arg2 ;
4400 double arg3 ;
4401 PyObject * obj0 = 0 ;
4402 PyObject * obj1 = 0 ;
4403 PyObject * obj2 = 0 ;
4404 char *kwnames[] = {
4405 (char *) "self",(char *) "x",(char *) "y", NULL
4406 };
4407
4408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4410 if (SWIG_arg_fail(1)) SWIG_fail;
4411 {
4412 arg2 = static_cast<double >(SWIG_As_double(obj1));
4413 if (SWIG_arg_fail(2)) SWIG_fail;
4414 }
4415 {
4416 arg3 = static_cast<double >(SWIG_As_double(obj2));
4417 if (SWIG_arg_fail(3)) SWIG_fail;
4418 }
4419 {
4420 PyThreadState* __tstate = wxPyBeginAllowThreads();
4421 wxRealPoint_Set(arg1,arg2,arg3);
4422
4423 wxPyEndAllowThreads(__tstate);
4424 if (PyErr_Occurred()) SWIG_fail;
4425 }
4426 Py_INCREF(Py_None); resultobj = Py_None;
4427 return resultobj;
4428 fail:
4429 return NULL;
4430 }
4431
4432
4433 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4434 PyObject *resultobj = NULL;
4435 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4436 PyObject *result;
4437 PyObject * obj0 = 0 ;
4438 char *kwnames[] = {
4439 (char *) "self", NULL
4440 };
4441
4442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4444 if (SWIG_arg_fail(1)) SWIG_fail;
4445 {
4446 PyThreadState* __tstate = wxPyBeginAllowThreads();
4447 result = (PyObject *)wxRealPoint_Get(arg1);
4448
4449 wxPyEndAllowThreads(__tstate);
4450 if (PyErr_Occurred()) SWIG_fail;
4451 }
4452 resultobj = result;
4453 return resultobj;
4454 fail:
4455 return NULL;
4456 }
4457
4458
4459 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4460 PyObject *obj;
4461 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4462 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4463 Py_INCREF(obj);
4464 return Py_BuildValue((char *)"");
4465 }
4466 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4467 PyObject *resultobj = NULL;
4468 wxPoint *arg1 = (wxPoint *) 0 ;
4469 int arg2 ;
4470 PyObject * obj0 = 0 ;
4471 PyObject * obj1 = 0 ;
4472 char *kwnames[] = {
4473 (char *) "self",(char *) "x", NULL
4474 };
4475
4476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4478 if (SWIG_arg_fail(1)) SWIG_fail;
4479 {
4480 arg2 = static_cast<int >(SWIG_As_int(obj1));
4481 if (SWIG_arg_fail(2)) SWIG_fail;
4482 }
4483 if (arg1) (arg1)->x = arg2;
4484
4485 Py_INCREF(Py_None); resultobj = Py_None;
4486 return resultobj;
4487 fail:
4488 return NULL;
4489 }
4490
4491
4492 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4493 PyObject *resultobj = NULL;
4494 wxPoint *arg1 = (wxPoint *) 0 ;
4495 int result;
4496 PyObject * obj0 = 0 ;
4497 char *kwnames[] = {
4498 (char *) "self", NULL
4499 };
4500
4501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4503 if (SWIG_arg_fail(1)) SWIG_fail;
4504 result = (int) ((arg1)->x);
4505
4506 {
4507 resultobj = SWIG_From_int(static_cast<int >(result));
4508 }
4509 return resultobj;
4510 fail:
4511 return NULL;
4512 }
4513
4514
4515 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4516 PyObject *resultobj = NULL;
4517 wxPoint *arg1 = (wxPoint *) 0 ;
4518 int arg2 ;
4519 PyObject * obj0 = 0 ;
4520 PyObject * obj1 = 0 ;
4521 char *kwnames[] = {
4522 (char *) "self",(char *) "y", NULL
4523 };
4524
4525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4527 if (SWIG_arg_fail(1)) SWIG_fail;
4528 {
4529 arg2 = static_cast<int >(SWIG_As_int(obj1));
4530 if (SWIG_arg_fail(2)) SWIG_fail;
4531 }
4532 if (arg1) (arg1)->y = arg2;
4533
4534 Py_INCREF(Py_None); resultobj = Py_None;
4535 return resultobj;
4536 fail:
4537 return NULL;
4538 }
4539
4540
4541 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4542 PyObject *resultobj = NULL;
4543 wxPoint *arg1 = (wxPoint *) 0 ;
4544 int result;
4545 PyObject * obj0 = 0 ;
4546 char *kwnames[] = {
4547 (char *) "self", NULL
4548 };
4549
4550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4552 if (SWIG_arg_fail(1)) SWIG_fail;
4553 result = (int) ((arg1)->y);
4554
4555 {
4556 resultobj = SWIG_From_int(static_cast<int >(result));
4557 }
4558 return resultobj;
4559 fail:
4560 return NULL;
4561 }
4562
4563
4564 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4565 PyObject *resultobj = NULL;
4566 int arg1 = (int) 0 ;
4567 int arg2 = (int) 0 ;
4568 wxPoint *result;
4569 PyObject * obj0 = 0 ;
4570 PyObject * obj1 = 0 ;
4571 char *kwnames[] = {
4572 (char *) "x",(char *) "y", NULL
4573 };
4574
4575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4576 if (obj0) {
4577 {
4578 arg1 = static_cast<int >(SWIG_As_int(obj0));
4579 if (SWIG_arg_fail(1)) SWIG_fail;
4580 }
4581 }
4582 if (obj1) {
4583 {
4584 arg2 = static_cast<int >(SWIG_As_int(obj1));
4585 if (SWIG_arg_fail(2)) SWIG_fail;
4586 }
4587 }
4588 {
4589 PyThreadState* __tstate = wxPyBeginAllowThreads();
4590 result = (wxPoint *)new wxPoint(arg1,arg2);
4591
4592 wxPyEndAllowThreads(__tstate);
4593 if (PyErr_Occurred()) SWIG_fail;
4594 }
4595 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4596 return resultobj;
4597 fail:
4598 return NULL;
4599 }
4600
4601
4602 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4603 PyObject *resultobj = NULL;
4604 wxPoint *arg1 = (wxPoint *) 0 ;
4605 PyObject * obj0 = 0 ;
4606 char *kwnames[] = {
4607 (char *) "self", NULL
4608 };
4609
4610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4612 if (SWIG_arg_fail(1)) SWIG_fail;
4613 {
4614 PyThreadState* __tstate = wxPyBeginAllowThreads();
4615 delete arg1;
4616
4617 wxPyEndAllowThreads(__tstate);
4618 if (PyErr_Occurred()) SWIG_fail;
4619 }
4620 Py_INCREF(Py_None); resultobj = Py_None;
4621 return resultobj;
4622 fail:
4623 return NULL;
4624 }
4625
4626
4627 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4628 PyObject *resultobj = NULL;
4629 wxPoint *arg1 = (wxPoint *) 0 ;
4630 wxPoint *arg2 = 0 ;
4631 bool result;
4632 wxPoint temp2 ;
4633 PyObject * obj0 = 0 ;
4634 PyObject * obj1 = 0 ;
4635 char *kwnames[] = {
4636 (char *) "self",(char *) "pt", NULL
4637 };
4638
4639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4641 if (SWIG_arg_fail(1)) SWIG_fail;
4642 {
4643 arg2 = &temp2;
4644 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4645 }
4646 {
4647 PyThreadState* __tstate = wxPyBeginAllowThreads();
4648 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4649
4650 wxPyEndAllowThreads(__tstate);
4651 if (PyErr_Occurred()) SWIG_fail;
4652 }
4653 {
4654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4655 }
4656 return resultobj;
4657 fail:
4658 return NULL;
4659 }
4660
4661
4662 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4663 PyObject *resultobj = NULL;
4664 wxPoint *arg1 = (wxPoint *) 0 ;
4665 wxPoint *arg2 = 0 ;
4666 bool result;
4667 wxPoint temp2 ;
4668 PyObject * obj0 = 0 ;
4669 PyObject * obj1 = 0 ;
4670 char *kwnames[] = {
4671 (char *) "self",(char *) "pt", NULL
4672 };
4673
4674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4676 if (SWIG_arg_fail(1)) SWIG_fail;
4677 {
4678 arg2 = &temp2;
4679 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4680 }
4681 {
4682 PyThreadState* __tstate = wxPyBeginAllowThreads();
4683 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4684
4685 wxPyEndAllowThreads(__tstate);
4686 if (PyErr_Occurred()) SWIG_fail;
4687 }
4688 {
4689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4690 }
4691 return resultobj;
4692 fail:
4693 return NULL;
4694 }
4695
4696
4697 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4698 PyObject *resultobj = NULL;
4699 wxPoint *arg1 = (wxPoint *) 0 ;
4700 wxPoint *arg2 = 0 ;
4701 wxPoint result;
4702 wxPoint temp2 ;
4703 PyObject * obj0 = 0 ;
4704 PyObject * obj1 = 0 ;
4705 char *kwnames[] = {
4706 (char *) "self",(char *) "pt", NULL
4707 };
4708
4709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4711 if (SWIG_arg_fail(1)) SWIG_fail;
4712 {
4713 arg2 = &temp2;
4714 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4715 }
4716 {
4717 PyThreadState* __tstate = wxPyBeginAllowThreads();
4718 result = (arg1)->operator +((wxPoint const &)*arg2);
4719
4720 wxPyEndAllowThreads(__tstate);
4721 if (PyErr_Occurred()) SWIG_fail;
4722 }
4723 {
4724 wxPoint * resultptr;
4725 resultptr = new wxPoint(static_cast<wxPoint & >(result));
4726 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4727 }
4728 return resultobj;
4729 fail:
4730 return NULL;
4731 }
4732
4733
4734 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4735 PyObject *resultobj = NULL;
4736 wxPoint *arg1 = (wxPoint *) 0 ;
4737 wxPoint *arg2 = 0 ;
4738 wxPoint result;
4739 wxPoint temp2 ;
4740 PyObject * obj0 = 0 ;
4741 PyObject * obj1 = 0 ;
4742 char *kwnames[] = {
4743 (char *) "self",(char *) "pt", NULL
4744 };
4745
4746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4748 if (SWIG_arg_fail(1)) SWIG_fail;
4749 {
4750 arg2 = &temp2;
4751 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4752 }
4753 {
4754 PyThreadState* __tstate = wxPyBeginAllowThreads();
4755 result = (arg1)->operator -((wxPoint const &)*arg2);
4756
4757 wxPyEndAllowThreads(__tstate);
4758 if (PyErr_Occurred()) SWIG_fail;
4759 }
4760 {
4761 wxPoint * resultptr;
4762 resultptr = new wxPoint(static_cast<wxPoint & >(result));
4763 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4764 }
4765 return resultobj;
4766 fail:
4767 return NULL;
4768 }
4769
4770
4771 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4772 PyObject *resultobj = NULL;
4773 wxPoint *arg1 = (wxPoint *) 0 ;
4774 wxPoint *arg2 = 0 ;
4775 wxPoint *result;
4776 wxPoint temp2 ;
4777 PyObject * obj0 = 0 ;
4778 PyObject * obj1 = 0 ;
4779 char *kwnames[] = {
4780 (char *) "self",(char *) "pt", NULL
4781 };
4782
4783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4785 if (SWIG_arg_fail(1)) SWIG_fail;
4786 {
4787 arg2 = &temp2;
4788 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4789 }
4790 {
4791 PyThreadState* __tstate = wxPyBeginAllowThreads();
4792 {
4793 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4794 result = (wxPoint *) &_result_ref;
4795 }
4796
4797 wxPyEndAllowThreads(__tstate);
4798 if (PyErr_Occurred()) SWIG_fail;
4799 }
4800 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4801 return resultobj;
4802 fail:
4803 return NULL;
4804 }
4805
4806
4807 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4808 PyObject *resultobj = NULL;
4809 wxPoint *arg1 = (wxPoint *) 0 ;
4810 wxPoint *arg2 = 0 ;
4811 wxPoint *result;
4812 wxPoint temp2 ;
4813 PyObject * obj0 = 0 ;
4814 PyObject * obj1 = 0 ;
4815 char *kwnames[] = {
4816 (char *) "self",(char *) "pt", NULL
4817 };
4818
4819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4821 if (SWIG_arg_fail(1)) SWIG_fail;
4822 {
4823 arg2 = &temp2;
4824 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4825 }
4826 {
4827 PyThreadState* __tstate = wxPyBeginAllowThreads();
4828 {
4829 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4830 result = (wxPoint *) &_result_ref;
4831 }
4832
4833 wxPyEndAllowThreads(__tstate);
4834 if (PyErr_Occurred()) SWIG_fail;
4835 }
4836 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4837 return resultobj;
4838 fail:
4839 return NULL;
4840 }
4841
4842
4843 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4844 PyObject *resultobj = NULL;
4845 wxPoint *arg1 = (wxPoint *) 0 ;
4846 long arg2 ;
4847 long arg3 ;
4848 PyObject * obj0 = 0 ;
4849 PyObject * obj1 = 0 ;
4850 PyObject * obj2 = 0 ;
4851 char *kwnames[] = {
4852 (char *) "self",(char *) "x",(char *) "y", NULL
4853 };
4854
4855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4857 if (SWIG_arg_fail(1)) SWIG_fail;
4858 {
4859 arg2 = static_cast<long >(SWIG_As_long(obj1));
4860 if (SWIG_arg_fail(2)) SWIG_fail;
4861 }
4862 {
4863 arg3 = static_cast<long >(SWIG_As_long(obj2));
4864 if (SWIG_arg_fail(3)) SWIG_fail;
4865 }
4866 {
4867 PyThreadState* __tstate = wxPyBeginAllowThreads();
4868 wxPoint_Set(arg1,arg2,arg3);
4869
4870 wxPyEndAllowThreads(__tstate);
4871 if (PyErr_Occurred()) SWIG_fail;
4872 }
4873 Py_INCREF(Py_None); resultobj = Py_None;
4874 return resultobj;
4875 fail:
4876 return NULL;
4877 }
4878
4879
4880 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4881 PyObject *resultobj = NULL;
4882 wxPoint *arg1 = (wxPoint *) 0 ;
4883 PyObject *result;
4884 PyObject * obj0 = 0 ;
4885 char *kwnames[] = {
4886 (char *) "self", NULL
4887 };
4888
4889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4891 if (SWIG_arg_fail(1)) SWIG_fail;
4892 {
4893 PyThreadState* __tstate = wxPyBeginAllowThreads();
4894 result = (PyObject *)wxPoint_Get(arg1);
4895
4896 wxPyEndAllowThreads(__tstate);
4897 if (PyErr_Occurred()) SWIG_fail;
4898 }
4899 resultobj = result;
4900 return resultobj;
4901 fail:
4902 return NULL;
4903 }
4904
4905
4906 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4907 PyObject *obj;
4908 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4909 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4910 Py_INCREF(obj);
4911 return Py_BuildValue((char *)"");
4912 }
4913 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4914 PyObject *resultobj = NULL;
4915 int arg1 = (int) 0 ;
4916 int arg2 = (int) 0 ;
4917 int arg3 = (int) 0 ;
4918 int arg4 = (int) 0 ;
4919 wxRect *result;
4920 PyObject * obj0 = 0 ;
4921 PyObject * obj1 = 0 ;
4922 PyObject * obj2 = 0 ;
4923 PyObject * obj3 = 0 ;
4924 char *kwnames[] = {
4925 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4926 };
4927
4928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4929 if (obj0) {
4930 {
4931 arg1 = static_cast<int >(SWIG_As_int(obj0));
4932 if (SWIG_arg_fail(1)) SWIG_fail;
4933 }
4934 }
4935 if (obj1) {
4936 {
4937 arg2 = static_cast<int >(SWIG_As_int(obj1));
4938 if (SWIG_arg_fail(2)) SWIG_fail;
4939 }
4940 }
4941 if (obj2) {
4942 {
4943 arg3 = static_cast<int >(SWIG_As_int(obj2));
4944 if (SWIG_arg_fail(3)) SWIG_fail;
4945 }
4946 }
4947 if (obj3) {
4948 {
4949 arg4 = static_cast<int >(SWIG_As_int(obj3));
4950 if (SWIG_arg_fail(4)) SWIG_fail;
4951 }
4952 }
4953 {
4954 PyThreadState* __tstate = wxPyBeginAllowThreads();
4955 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4956
4957 wxPyEndAllowThreads(__tstate);
4958 if (PyErr_Occurred()) SWIG_fail;
4959 }
4960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4961 return resultobj;
4962 fail:
4963 return NULL;
4964 }
4965
4966
4967 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4968 PyObject *resultobj = NULL;
4969 wxPoint *arg1 = 0 ;
4970 wxPoint *arg2 = 0 ;
4971 wxRect *result;
4972 wxPoint temp1 ;
4973 wxPoint temp2 ;
4974 PyObject * obj0 = 0 ;
4975 PyObject * obj1 = 0 ;
4976 char *kwnames[] = {
4977 (char *) "topLeft",(char *) "bottomRight", NULL
4978 };
4979
4980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4981 {
4982 arg1 = &temp1;
4983 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4984 }
4985 {
4986 arg2 = &temp2;
4987 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4988 }
4989 {
4990 PyThreadState* __tstate = wxPyBeginAllowThreads();
4991 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4992
4993 wxPyEndAllowThreads(__tstate);
4994 if (PyErr_Occurred()) SWIG_fail;
4995 }
4996 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4997 return resultobj;
4998 fail:
4999 return NULL;
5000 }
5001
5002
5003 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
5004 PyObject *resultobj = NULL;
5005 wxPoint *arg1 = 0 ;
5006 wxSize *arg2 = 0 ;
5007 wxRect *result;
5008 wxPoint temp1 ;
5009 wxSize temp2 ;
5010 PyObject * obj0 = 0 ;
5011 PyObject * obj1 = 0 ;
5012 char *kwnames[] = {
5013 (char *) "pos",(char *) "size", NULL
5014 };
5015
5016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
5017 {
5018 arg1 = &temp1;
5019 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5020 }
5021 {
5022 arg2 = &temp2;
5023 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5024 }
5025 {
5026 PyThreadState* __tstate = wxPyBeginAllowThreads();
5027 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
5028
5029 wxPyEndAllowThreads(__tstate);
5030 if (PyErr_Occurred()) SWIG_fail;
5031 }
5032 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5033 return resultobj;
5034 fail:
5035 return NULL;
5036 }
5037
5038
5039 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
5040 PyObject *resultobj = NULL;
5041 wxSize *arg1 = 0 ;
5042 wxRect *result;
5043 wxSize temp1 ;
5044 PyObject * obj0 = 0 ;
5045 char *kwnames[] = {
5046 (char *) "size", NULL
5047 };
5048
5049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
5050 {
5051 arg1 = &temp1;
5052 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
5053 }
5054 {
5055 PyThreadState* __tstate = wxPyBeginAllowThreads();
5056 result = (wxRect *)new wxRect((wxSize const &)*arg1);
5057
5058 wxPyEndAllowThreads(__tstate);
5059 if (PyErr_Occurred()) SWIG_fail;
5060 }
5061 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5062 return resultobj;
5063 fail:
5064 return NULL;
5065 }
5066
5067
5068 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
5069 PyObject *resultobj = NULL;
5070 wxRect *arg1 = (wxRect *) 0 ;
5071 PyObject * obj0 = 0 ;
5072 char *kwnames[] = {
5073 (char *) "self", NULL
5074 };
5075
5076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
5077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5078 if (SWIG_arg_fail(1)) SWIG_fail;
5079 {
5080 PyThreadState* __tstate = wxPyBeginAllowThreads();
5081 delete arg1;
5082
5083 wxPyEndAllowThreads(__tstate);
5084 if (PyErr_Occurred()) SWIG_fail;
5085 }
5086 Py_INCREF(Py_None); resultobj = Py_None;
5087 return resultobj;
5088 fail:
5089 return NULL;
5090 }
5091
5092
5093 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
5094 PyObject *resultobj = NULL;
5095 wxRect *arg1 = (wxRect *) 0 ;
5096 int result;
5097 PyObject * obj0 = 0 ;
5098 char *kwnames[] = {
5099 (char *) "self", NULL
5100 };
5101
5102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
5103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5104 if (SWIG_arg_fail(1)) SWIG_fail;
5105 {
5106 PyThreadState* __tstate = wxPyBeginAllowThreads();
5107 result = (int)((wxRect const *)arg1)->GetX();
5108
5109 wxPyEndAllowThreads(__tstate);
5110 if (PyErr_Occurred()) SWIG_fail;
5111 }
5112 {
5113 resultobj = SWIG_From_int(static_cast<int >(result));
5114 }
5115 return resultobj;
5116 fail:
5117 return NULL;
5118 }
5119
5120
5121 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
5122 PyObject *resultobj = NULL;
5123 wxRect *arg1 = (wxRect *) 0 ;
5124 int arg2 ;
5125 PyObject * obj0 = 0 ;
5126 PyObject * obj1 = 0 ;
5127 char *kwnames[] = {
5128 (char *) "self",(char *) "x", NULL
5129 };
5130
5131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
5132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5133 if (SWIG_arg_fail(1)) SWIG_fail;
5134 {
5135 arg2 = static_cast<int >(SWIG_As_int(obj1));
5136 if (SWIG_arg_fail(2)) SWIG_fail;
5137 }
5138 {
5139 PyThreadState* __tstate = wxPyBeginAllowThreads();
5140 (arg1)->SetX(arg2);
5141
5142 wxPyEndAllowThreads(__tstate);
5143 if (PyErr_Occurred()) SWIG_fail;
5144 }
5145 Py_INCREF(Py_None); resultobj = Py_None;
5146 return resultobj;
5147 fail:
5148 return NULL;
5149 }
5150
5151
5152 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5153 PyObject *resultobj = NULL;
5154 wxRect *arg1 = (wxRect *) 0 ;
5155 int result;
5156 PyObject * obj0 = 0 ;
5157 char *kwnames[] = {
5158 (char *) "self", NULL
5159 };
5160
5161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5163 if (SWIG_arg_fail(1)) SWIG_fail;
5164 {
5165 PyThreadState* __tstate = wxPyBeginAllowThreads();
5166 result = (int)(arg1)->GetY();
5167
5168 wxPyEndAllowThreads(__tstate);
5169 if (PyErr_Occurred()) SWIG_fail;
5170 }
5171 {
5172 resultobj = SWIG_From_int(static_cast<int >(result));
5173 }
5174 return resultobj;
5175 fail:
5176 return NULL;
5177 }
5178
5179
5180 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5181 PyObject *resultobj = NULL;
5182 wxRect *arg1 = (wxRect *) 0 ;
5183 int arg2 ;
5184 PyObject * obj0 = 0 ;
5185 PyObject * obj1 = 0 ;
5186 char *kwnames[] = {
5187 (char *) "self",(char *) "y", NULL
5188 };
5189
5190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5192 if (SWIG_arg_fail(1)) SWIG_fail;
5193 {
5194 arg2 = static_cast<int >(SWIG_As_int(obj1));
5195 if (SWIG_arg_fail(2)) SWIG_fail;
5196 }
5197 {
5198 PyThreadState* __tstate = wxPyBeginAllowThreads();
5199 (arg1)->SetY(arg2);
5200
5201 wxPyEndAllowThreads(__tstate);
5202 if (PyErr_Occurred()) SWIG_fail;
5203 }
5204 Py_INCREF(Py_None); resultobj = Py_None;
5205 return resultobj;
5206 fail:
5207 return NULL;
5208 }
5209
5210
5211 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5212 PyObject *resultobj = NULL;
5213 wxRect *arg1 = (wxRect *) 0 ;
5214 int result;
5215 PyObject * obj0 = 0 ;
5216 char *kwnames[] = {
5217 (char *) "self", NULL
5218 };
5219
5220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5222 if (SWIG_arg_fail(1)) SWIG_fail;
5223 {
5224 PyThreadState* __tstate = wxPyBeginAllowThreads();
5225 result = (int)((wxRect const *)arg1)->GetWidth();
5226
5227 wxPyEndAllowThreads(__tstate);
5228 if (PyErr_Occurred()) SWIG_fail;
5229 }
5230 {
5231 resultobj = SWIG_From_int(static_cast<int >(result));
5232 }
5233 return resultobj;
5234 fail:
5235 return NULL;
5236 }
5237
5238
5239 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5240 PyObject *resultobj = NULL;
5241 wxRect *arg1 = (wxRect *) 0 ;
5242 int arg2 ;
5243 PyObject * obj0 = 0 ;
5244 PyObject * obj1 = 0 ;
5245 char *kwnames[] = {
5246 (char *) "self",(char *) "w", NULL
5247 };
5248
5249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5251 if (SWIG_arg_fail(1)) SWIG_fail;
5252 {
5253 arg2 = static_cast<int >(SWIG_As_int(obj1));
5254 if (SWIG_arg_fail(2)) SWIG_fail;
5255 }
5256 {
5257 PyThreadState* __tstate = wxPyBeginAllowThreads();
5258 (arg1)->SetWidth(arg2);
5259
5260 wxPyEndAllowThreads(__tstate);
5261 if (PyErr_Occurred()) SWIG_fail;
5262 }
5263 Py_INCREF(Py_None); resultobj = Py_None;
5264 return resultobj;
5265 fail:
5266 return NULL;
5267 }
5268
5269
5270 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5271 PyObject *resultobj = NULL;
5272 wxRect *arg1 = (wxRect *) 0 ;
5273 int result;
5274 PyObject * obj0 = 0 ;
5275 char *kwnames[] = {
5276 (char *) "self", NULL
5277 };
5278
5279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5281 if (SWIG_arg_fail(1)) SWIG_fail;
5282 {
5283 PyThreadState* __tstate = wxPyBeginAllowThreads();
5284 result = (int)((wxRect const *)arg1)->GetHeight();
5285
5286 wxPyEndAllowThreads(__tstate);
5287 if (PyErr_Occurred()) SWIG_fail;
5288 }
5289 {
5290 resultobj = SWIG_From_int(static_cast<int >(result));
5291 }
5292 return resultobj;
5293 fail:
5294 return NULL;
5295 }
5296
5297
5298 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5299 PyObject *resultobj = NULL;
5300 wxRect *arg1 = (wxRect *) 0 ;
5301 int arg2 ;
5302 PyObject * obj0 = 0 ;
5303 PyObject * obj1 = 0 ;
5304 char *kwnames[] = {
5305 (char *) "self",(char *) "h", NULL
5306 };
5307
5308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5310 if (SWIG_arg_fail(1)) SWIG_fail;
5311 {
5312 arg2 = static_cast<int >(SWIG_As_int(obj1));
5313 if (SWIG_arg_fail(2)) SWIG_fail;
5314 }
5315 {
5316 PyThreadState* __tstate = wxPyBeginAllowThreads();
5317 (arg1)->SetHeight(arg2);
5318
5319 wxPyEndAllowThreads(__tstate);
5320 if (PyErr_Occurred()) SWIG_fail;
5321 }
5322 Py_INCREF(Py_None); resultobj = Py_None;
5323 return resultobj;
5324 fail:
5325 return NULL;
5326 }
5327
5328
5329 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5330 PyObject *resultobj = NULL;
5331 wxRect *arg1 = (wxRect *) 0 ;
5332 wxPoint result;
5333 PyObject * obj0 = 0 ;
5334 char *kwnames[] = {
5335 (char *) "self", NULL
5336 };
5337
5338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5340 if (SWIG_arg_fail(1)) SWIG_fail;
5341 {
5342 PyThreadState* __tstate = wxPyBeginAllowThreads();
5343 result = ((wxRect const *)arg1)->GetPosition();
5344
5345 wxPyEndAllowThreads(__tstate);
5346 if (PyErr_Occurred()) SWIG_fail;
5347 }
5348 {
5349 wxPoint * resultptr;
5350 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5351 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5352 }
5353 return resultobj;
5354 fail:
5355 return NULL;
5356 }
5357
5358
5359 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5360 PyObject *resultobj = NULL;
5361 wxRect *arg1 = (wxRect *) 0 ;
5362 wxPoint *arg2 = 0 ;
5363 wxPoint temp2 ;
5364 PyObject * obj0 = 0 ;
5365 PyObject * obj1 = 0 ;
5366 char *kwnames[] = {
5367 (char *) "self",(char *) "p", NULL
5368 };
5369
5370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5372 if (SWIG_arg_fail(1)) SWIG_fail;
5373 {
5374 arg2 = &temp2;
5375 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5376 }
5377 {
5378 PyThreadState* __tstate = wxPyBeginAllowThreads();
5379 (arg1)->SetPosition((wxPoint const &)*arg2);
5380
5381 wxPyEndAllowThreads(__tstate);
5382 if (PyErr_Occurred()) SWIG_fail;
5383 }
5384 Py_INCREF(Py_None); resultobj = Py_None;
5385 return resultobj;
5386 fail:
5387 return NULL;
5388 }
5389
5390
5391 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5392 PyObject *resultobj = NULL;
5393 wxRect *arg1 = (wxRect *) 0 ;
5394 wxSize result;
5395 PyObject * obj0 = 0 ;
5396 char *kwnames[] = {
5397 (char *) "self", NULL
5398 };
5399
5400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5402 if (SWIG_arg_fail(1)) SWIG_fail;
5403 {
5404 PyThreadState* __tstate = wxPyBeginAllowThreads();
5405 result = ((wxRect const *)arg1)->GetSize();
5406
5407 wxPyEndAllowThreads(__tstate);
5408 if (PyErr_Occurred()) SWIG_fail;
5409 }
5410 {
5411 wxSize * resultptr;
5412 resultptr = new wxSize(static_cast<wxSize & >(result));
5413 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5414 }
5415 return resultobj;
5416 fail:
5417 return NULL;
5418 }
5419
5420
5421 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5422 PyObject *resultobj = NULL;
5423 wxRect *arg1 = (wxRect *) 0 ;
5424 wxSize *arg2 = 0 ;
5425 wxSize temp2 ;
5426 PyObject * obj0 = 0 ;
5427 PyObject * obj1 = 0 ;
5428 char *kwnames[] = {
5429 (char *) "self",(char *) "s", NULL
5430 };
5431
5432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5434 if (SWIG_arg_fail(1)) SWIG_fail;
5435 {
5436 arg2 = &temp2;
5437 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5438 }
5439 {
5440 PyThreadState* __tstate = wxPyBeginAllowThreads();
5441 (arg1)->SetSize((wxSize const &)*arg2);
5442
5443 wxPyEndAllowThreads(__tstate);
5444 if (PyErr_Occurred()) SWIG_fail;
5445 }
5446 Py_INCREF(Py_None); resultobj = Py_None;
5447 return resultobj;
5448 fail:
5449 return NULL;
5450 }
5451
5452
5453 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5454 PyObject *resultobj = NULL;
5455 wxRect *arg1 = (wxRect *) 0 ;
5456 bool result;
5457 PyObject * obj0 = 0 ;
5458 char *kwnames[] = {
5459 (char *) "self", NULL
5460 };
5461
5462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5464 if (SWIG_arg_fail(1)) SWIG_fail;
5465 {
5466 PyThreadState* __tstate = wxPyBeginAllowThreads();
5467 result = (bool)((wxRect const *)arg1)->IsEmpty();
5468
5469 wxPyEndAllowThreads(__tstate);
5470 if (PyErr_Occurred()) SWIG_fail;
5471 }
5472 {
5473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5474 }
5475 return resultobj;
5476 fail:
5477 return NULL;
5478 }
5479
5480
5481 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5482 PyObject *resultobj = NULL;
5483 wxRect *arg1 = (wxRect *) 0 ;
5484 wxPoint result;
5485 PyObject * obj0 = 0 ;
5486 char *kwnames[] = {
5487 (char *) "self", NULL
5488 };
5489
5490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5492 if (SWIG_arg_fail(1)) SWIG_fail;
5493 {
5494 PyThreadState* __tstate = wxPyBeginAllowThreads();
5495 result = ((wxRect const *)arg1)->GetTopLeft();
5496
5497 wxPyEndAllowThreads(__tstate);
5498 if (PyErr_Occurred()) SWIG_fail;
5499 }
5500 {
5501 wxPoint * resultptr;
5502 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5503 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5504 }
5505 return resultobj;
5506 fail:
5507 return NULL;
5508 }
5509
5510
5511 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5512 PyObject *resultobj = NULL;
5513 wxRect *arg1 = (wxRect *) 0 ;
5514 wxPoint *arg2 = 0 ;
5515 wxPoint temp2 ;
5516 PyObject * obj0 = 0 ;
5517 PyObject * obj1 = 0 ;
5518 char *kwnames[] = {
5519 (char *) "self",(char *) "p", NULL
5520 };
5521
5522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5524 if (SWIG_arg_fail(1)) SWIG_fail;
5525 {
5526 arg2 = &temp2;
5527 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5528 }
5529 {
5530 PyThreadState* __tstate = wxPyBeginAllowThreads();
5531 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5532
5533 wxPyEndAllowThreads(__tstate);
5534 if (PyErr_Occurred()) SWIG_fail;
5535 }
5536 Py_INCREF(Py_None); resultobj = Py_None;
5537 return resultobj;
5538 fail:
5539 return NULL;
5540 }
5541
5542
5543 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5544 PyObject *resultobj = NULL;
5545 wxRect *arg1 = (wxRect *) 0 ;
5546 wxPoint result;
5547 PyObject * obj0 = 0 ;
5548 char *kwnames[] = {
5549 (char *) "self", NULL
5550 };
5551
5552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5554 if (SWIG_arg_fail(1)) SWIG_fail;
5555 {
5556 PyThreadState* __tstate = wxPyBeginAllowThreads();
5557 result = ((wxRect const *)arg1)->GetBottomRight();
5558
5559 wxPyEndAllowThreads(__tstate);
5560 if (PyErr_Occurred()) SWIG_fail;
5561 }
5562 {
5563 wxPoint * resultptr;
5564 resultptr = new wxPoint(static_cast<wxPoint & >(result));
5565 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5566 }
5567 return resultobj;
5568 fail:
5569 return NULL;
5570 }
5571
5572
5573 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5574 PyObject *resultobj = NULL;
5575 wxRect *arg1 = (wxRect *) 0 ;
5576 wxPoint *arg2 = 0 ;
5577 wxPoint temp2 ;
5578 PyObject * obj0 = 0 ;
5579 PyObject * obj1 = 0 ;
5580 char *kwnames[] = {
5581 (char *) "self",(char *) "p", NULL
5582 };
5583
5584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5586 if (SWIG_arg_fail(1)) SWIG_fail;
5587 {
5588 arg2 = &temp2;
5589 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5590 }
5591 {
5592 PyThreadState* __tstate = wxPyBeginAllowThreads();
5593 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5594
5595 wxPyEndAllowThreads(__tstate);
5596 if (PyErr_Occurred()) SWIG_fail;
5597 }
5598 Py_INCREF(Py_None); resultobj = Py_None;
5599 return resultobj;
5600 fail:
5601 return NULL;
5602 }
5603
5604
5605 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5606 PyObject *resultobj = NULL;
5607 wxRect *arg1 = (wxRect *) 0 ;
5608 int result;
5609 PyObject * obj0 = 0 ;
5610 char *kwnames[] = {
5611 (char *) "self", NULL
5612 };
5613
5614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5616 if (SWIG_arg_fail(1)) SWIG_fail;
5617 {
5618 PyThreadState* __tstate = wxPyBeginAllowThreads();
5619 result = (int)((wxRect const *)arg1)->GetLeft();
5620
5621 wxPyEndAllowThreads(__tstate);
5622 if (PyErr_Occurred()) SWIG_fail;
5623 }
5624 {
5625 resultobj = SWIG_From_int(static_cast<int >(result));
5626 }
5627 return resultobj;
5628 fail:
5629 return NULL;
5630 }
5631
5632
5633 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5634 PyObject *resultobj = NULL;
5635 wxRect *arg1 = (wxRect *) 0 ;
5636 int result;
5637 PyObject * obj0 = 0 ;
5638 char *kwnames[] = {
5639 (char *) "self", NULL
5640 };
5641
5642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5644 if (SWIG_arg_fail(1)) SWIG_fail;
5645 {
5646 PyThreadState* __tstate = wxPyBeginAllowThreads();
5647 result = (int)((wxRect const *)arg1)->GetTop();
5648
5649 wxPyEndAllowThreads(__tstate);
5650 if (PyErr_Occurred()) SWIG_fail;
5651 }
5652 {
5653 resultobj = SWIG_From_int(static_cast<int >(result));
5654 }
5655 return resultobj;
5656 fail:
5657 return NULL;
5658 }
5659
5660
5661 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5662 PyObject *resultobj = NULL;
5663 wxRect *arg1 = (wxRect *) 0 ;
5664 int result;
5665 PyObject * obj0 = 0 ;
5666 char *kwnames[] = {
5667 (char *) "self", NULL
5668 };
5669
5670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5672 if (SWIG_arg_fail(1)) SWIG_fail;
5673 {
5674 PyThreadState* __tstate = wxPyBeginAllowThreads();
5675 result = (int)((wxRect const *)arg1)->GetBottom();
5676
5677 wxPyEndAllowThreads(__tstate);
5678 if (PyErr_Occurred()) SWIG_fail;
5679 }
5680 {
5681 resultobj = SWIG_From_int(static_cast<int >(result));
5682 }
5683 return resultobj;
5684 fail:
5685 return NULL;
5686 }
5687
5688
5689 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5690 PyObject *resultobj = NULL;
5691 wxRect *arg1 = (wxRect *) 0 ;
5692 int result;
5693 PyObject * obj0 = 0 ;
5694 char *kwnames[] = {
5695 (char *) "self", NULL
5696 };
5697
5698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5700 if (SWIG_arg_fail(1)) SWIG_fail;
5701 {
5702 PyThreadState* __tstate = wxPyBeginAllowThreads();
5703 result = (int)((wxRect const *)arg1)->GetRight();
5704
5705 wxPyEndAllowThreads(__tstate);
5706 if (PyErr_Occurred()) SWIG_fail;
5707 }
5708 {
5709 resultobj = SWIG_From_int(static_cast<int >(result));
5710 }
5711 return resultobj;
5712 fail:
5713 return NULL;
5714 }
5715
5716
5717 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5718 PyObject *resultobj = NULL;
5719 wxRect *arg1 = (wxRect *) 0 ;
5720 int arg2 ;
5721 PyObject * obj0 = 0 ;
5722 PyObject * obj1 = 0 ;
5723 char *kwnames[] = {
5724 (char *) "self",(char *) "left", NULL
5725 };
5726
5727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5729 if (SWIG_arg_fail(1)) SWIG_fail;
5730 {
5731 arg2 = static_cast<int >(SWIG_As_int(obj1));
5732 if (SWIG_arg_fail(2)) SWIG_fail;
5733 }
5734 {
5735 PyThreadState* __tstate = wxPyBeginAllowThreads();
5736 (arg1)->SetLeft(arg2);
5737
5738 wxPyEndAllowThreads(__tstate);
5739 if (PyErr_Occurred()) SWIG_fail;
5740 }
5741 Py_INCREF(Py_None); resultobj = Py_None;
5742 return resultobj;
5743 fail:
5744 return NULL;
5745 }
5746
5747
5748 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5749 PyObject *resultobj = NULL;
5750 wxRect *arg1 = (wxRect *) 0 ;
5751 int arg2 ;
5752 PyObject * obj0 = 0 ;
5753 PyObject * obj1 = 0 ;
5754 char *kwnames[] = {
5755 (char *) "self",(char *) "right", NULL
5756 };
5757
5758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5760 if (SWIG_arg_fail(1)) SWIG_fail;
5761 {
5762 arg2 = static_cast<int >(SWIG_As_int(obj1));
5763 if (SWIG_arg_fail(2)) SWIG_fail;
5764 }
5765 {
5766 PyThreadState* __tstate = wxPyBeginAllowThreads();
5767 (arg1)->SetRight(arg2);
5768
5769 wxPyEndAllowThreads(__tstate);
5770 if (PyErr_Occurred()) SWIG_fail;
5771 }
5772 Py_INCREF(Py_None); resultobj = Py_None;
5773 return resultobj;
5774 fail:
5775 return NULL;
5776 }
5777
5778
5779 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5780 PyObject *resultobj = NULL;
5781 wxRect *arg1 = (wxRect *) 0 ;
5782 int arg2 ;
5783 PyObject * obj0 = 0 ;
5784 PyObject * obj1 = 0 ;
5785 char *kwnames[] = {
5786 (char *) "self",(char *) "top", NULL
5787 };
5788
5789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5791 if (SWIG_arg_fail(1)) SWIG_fail;
5792 {
5793 arg2 = static_cast<int >(SWIG_As_int(obj1));
5794 if (SWIG_arg_fail(2)) SWIG_fail;
5795 }
5796 {
5797 PyThreadState* __tstate = wxPyBeginAllowThreads();
5798 (arg1)->SetTop(arg2);
5799
5800 wxPyEndAllowThreads(__tstate);
5801 if (PyErr_Occurred()) SWIG_fail;
5802 }
5803 Py_INCREF(Py_None); resultobj = Py_None;
5804 return resultobj;
5805 fail:
5806 return NULL;
5807 }
5808
5809
5810 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5811 PyObject *resultobj = NULL;
5812 wxRect *arg1 = (wxRect *) 0 ;
5813 int arg2 ;
5814 PyObject * obj0 = 0 ;
5815 PyObject * obj1 = 0 ;
5816 char *kwnames[] = {
5817 (char *) "self",(char *) "bottom", NULL
5818 };
5819
5820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5822 if (SWIG_arg_fail(1)) SWIG_fail;
5823 {
5824 arg2 = static_cast<int >(SWIG_As_int(obj1));
5825 if (SWIG_arg_fail(2)) SWIG_fail;
5826 }
5827 {
5828 PyThreadState* __tstate = wxPyBeginAllowThreads();
5829 (arg1)->SetBottom(arg2);
5830
5831 wxPyEndAllowThreads(__tstate);
5832 if (PyErr_Occurred()) SWIG_fail;
5833 }
5834 Py_INCREF(Py_None); resultobj = Py_None;
5835 return resultobj;
5836 fail:
5837 return NULL;
5838 }
5839
5840
5841 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5842 PyObject *resultobj = NULL;
5843 wxRect *arg1 = (wxRect *) 0 ;
5844 int arg2 ;
5845 int arg3 ;
5846 wxRect *result;
5847 PyObject * obj0 = 0 ;
5848 PyObject * obj1 = 0 ;
5849 PyObject * obj2 = 0 ;
5850 char *kwnames[] = {
5851 (char *) "self",(char *) "dx",(char *) "dy", NULL
5852 };
5853
5854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5856 if (SWIG_arg_fail(1)) SWIG_fail;
5857 {
5858 arg2 = static_cast<int >(SWIG_As_int(obj1));
5859 if (SWIG_arg_fail(2)) SWIG_fail;
5860 }
5861 {
5862 arg3 = static_cast<int >(SWIG_As_int(obj2));
5863 if (SWIG_arg_fail(3)) SWIG_fail;
5864 }
5865 {
5866 PyThreadState* __tstate = wxPyBeginAllowThreads();
5867 {
5868 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5869 result = (wxRect *) &_result_ref;
5870 }
5871
5872 wxPyEndAllowThreads(__tstate);
5873 if (PyErr_Occurred()) SWIG_fail;
5874 }
5875 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5876 return resultobj;
5877 fail:
5878 return NULL;
5879 }
5880
5881
5882 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5883 PyObject *resultobj = NULL;
5884 wxRect *arg1 = (wxRect *) 0 ;
5885 int arg2 ;
5886 int arg3 ;
5887 wxRect *result;
5888 PyObject * obj0 = 0 ;
5889 PyObject * obj1 = 0 ;
5890 PyObject * obj2 = 0 ;
5891 char *kwnames[] = {
5892 (char *) "self",(char *) "dx",(char *) "dy", NULL
5893 };
5894
5895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5897 if (SWIG_arg_fail(1)) SWIG_fail;
5898 {
5899 arg2 = static_cast<int >(SWIG_As_int(obj1));
5900 if (SWIG_arg_fail(2)) SWIG_fail;
5901 }
5902 {
5903 arg3 = static_cast<int >(SWIG_As_int(obj2));
5904 if (SWIG_arg_fail(3)) SWIG_fail;
5905 }
5906 {
5907 PyThreadState* __tstate = wxPyBeginAllowThreads();
5908 {
5909 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5910 result = (wxRect *) &_result_ref;
5911 }
5912
5913 wxPyEndAllowThreads(__tstate);
5914 if (PyErr_Occurred()) SWIG_fail;
5915 }
5916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5917 return resultobj;
5918 fail:
5919 return NULL;
5920 }
5921
5922
5923 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5924 PyObject *resultobj = NULL;
5925 wxRect *arg1 = (wxRect *) 0 ;
5926 int arg2 ;
5927 int arg3 ;
5928 PyObject * obj0 = 0 ;
5929 PyObject * obj1 = 0 ;
5930 PyObject * obj2 = 0 ;
5931 char *kwnames[] = {
5932 (char *) "self",(char *) "dx",(char *) "dy", NULL
5933 };
5934
5935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5937 if (SWIG_arg_fail(1)) SWIG_fail;
5938 {
5939 arg2 = static_cast<int >(SWIG_As_int(obj1));
5940 if (SWIG_arg_fail(2)) SWIG_fail;
5941 }
5942 {
5943 arg3 = static_cast<int >(SWIG_As_int(obj2));
5944 if (SWIG_arg_fail(3)) SWIG_fail;
5945 }
5946 {
5947 PyThreadState* __tstate = wxPyBeginAllowThreads();
5948 (arg1)->Offset(arg2,arg3);
5949
5950 wxPyEndAllowThreads(__tstate);
5951 if (PyErr_Occurred()) SWIG_fail;
5952 }
5953 Py_INCREF(Py_None); resultobj = Py_None;
5954 return resultobj;
5955 fail:
5956 return NULL;
5957 }
5958
5959
5960 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5961 PyObject *resultobj = NULL;
5962 wxRect *arg1 = (wxRect *) 0 ;
5963 wxPoint *arg2 = 0 ;
5964 wxPoint temp2 ;
5965 PyObject * obj0 = 0 ;
5966 PyObject * obj1 = 0 ;
5967 char *kwnames[] = {
5968 (char *) "self",(char *) "pt", NULL
5969 };
5970
5971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5973 if (SWIG_arg_fail(1)) SWIG_fail;
5974 {
5975 arg2 = &temp2;
5976 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5977 }
5978 {
5979 PyThreadState* __tstate = wxPyBeginAllowThreads();
5980 (arg1)->Offset((wxPoint const &)*arg2);
5981
5982 wxPyEndAllowThreads(__tstate);
5983 if (PyErr_Occurred()) SWIG_fail;
5984 }
5985 Py_INCREF(Py_None); resultobj = Py_None;
5986 return resultobj;
5987 fail:
5988 return NULL;
5989 }
5990
5991
5992 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5993 PyObject *resultobj = NULL;
5994 wxRect *arg1 = (wxRect *) 0 ;
5995 wxRect *arg2 = 0 ;
5996 wxRect result;
5997 wxRect temp2 ;
5998 PyObject * obj0 = 0 ;
5999 PyObject * obj1 = 0 ;
6000 char *kwnames[] = {
6001 (char *) "self",(char *) "rect", NULL
6002 };
6003
6004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
6005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6006 if (SWIG_arg_fail(1)) SWIG_fail;
6007 {
6008 arg2 = &temp2;
6009 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6010 }
6011 {
6012 PyThreadState* __tstate = wxPyBeginAllowThreads();
6013 result = (arg1)->Intersect((wxRect const &)*arg2);
6014
6015 wxPyEndAllowThreads(__tstate);
6016 if (PyErr_Occurred()) SWIG_fail;
6017 }
6018 {
6019 wxRect * resultptr;
6020 resultptr = new wxRect(static_cast<wxRect & >(result));
6021 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6022 }
6023 return resultobj;
6024 fail:
6025 return NULL;
6026 }
6027
6028
6029 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
6030 PyObject *resultobj = NULL;
6031 wxRect *arg1 = (wxRect *) 0 ;
6032 wxRect *arg2 = 0 ;
6033 wxRect result;
6034 wxRect temp2 ;
6035 PyObject * obj0 = 0 ;
6036 PyObject * obj1 = 0 ;
6037 char *kwnames[] = {
6038 (char *) "self",(char *) "rect", NULL
6039 };
6040
6041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
6042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6043 if (SWIG_arg_fail(1)) SWIG_fail;
6044 {
6045 arg2 = &temp2;
6046 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6047 }
6048 {
6049 PyThreadState* __tstate = wxPyBeginAllowThreads();
6050 result = (arg1)->Union((wxRect const &)*arg2);
6051
6052 wxPyEndAllowThreads(__tstate);
6053 if (PyErr_Occurred()) SWIG_fail;
6054 }
6055 {
6056 wxRect * resultptr;
6057 resultptr = new wxRect(static_cast<wxRect & >(result));
6058 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6059 }
6060 return resultobj;
6061 fail:
6062 return NULL;
6063 }
6064
6065
6066 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
6067 PyObject *resultobj = NULL;
6068 wxRect *arg1 = (wxRect *) 0 ;
6069 wxRect *arg2 = 0 ;
6070 wxRect result;
6071 wxRect temp2 ;
6072 PyObject * obj0 = 0 ;
6073 PyObject * obj1 = 0 ;
6074 char *kwnames[] = {
6075 (char *) "self",(char *) "rect", NULL
6076 };
6077
6078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
6079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6080 if (SWIG_arg_fail(1)) SWIG_fail;
6081 {
6082 arg2 = &temp2;
6083 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6084 }
6085 {
6086 PyThreadState* __tstate = wxPyBeginAllowThreads();
6087 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
6088
6089 wxPyEndAllowThreads(__tstate);
6090 if (PyErr_Occurred()) SWIG_fail;
6091 }
6092 {
6093 wxRect * resultptr;
6094 resultptr = new wxRect(static_cast<wxRect & >(result));
6095 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
6096 }
6097 return resultobj;
6098 fail:
6099 return NULL;
6100 }
6101
6102
6103 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6104 PyObject *resultobj = NULL;
6105 wxRect *arg1 = (wxRect *) 0 ;
6106 wxRect *arg2 = 0 ;
6107 wxRect *result;
6108 wxRect temp2 ;
6109 PyObject * obj0 = 0 ;
6110 PyObject * obj1 = 0 ;
6111 char *kwnames[] = {
6112 (char *) "self",(char *) "rect", NULL
6113 };
6114
6115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
6116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6117 if (SWIG_arg_fail(1)) SWIG_fail;
6118 {
6119 arg2 = &temp2;
6120 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6121 }
6122 {
6123 PyThreadState* __tstate = wxPyBeginAllowThreads();
6124 {
6125 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
6126 result = (wxRect *) &_result_ref;
6127 }
6128
6129 wxPyEndAllowThreads(__tstate);
6130 if (PyErr_Occurred()) SWIG_fail;
6131 }
6132 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
6133 return resultobj;
6134 fail:
6135 return NULL;
6136 }
6137
6138
6139 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6140 PyObject *resultobj = NULL;
6141 wxRect *arg1 = (wxRect *) 0 ;
6142 wxRect *arg2 = 0 ;
6143 bool result;
6144 wxRect temp2 ;
6145 PyObject * obj0 = 0 ;
6146 PyObject * obj1 = 0 ;
6147 char *kwnames[] = {
6148 (char *) "self",(char *) "rect", NULL
6149 };
6150
6151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6153 if (SWIG_arg_fail(1)) SWIG_fail;
6154 {
6155 arg2 = &temp2;
6156 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6157 }
6158 {
6159 PyThreadState* __tstate = wxPyBeginAllowThreads();
6160 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6161
6162 wxPyEndAllowThreads(__tstate);
6163 if (PyErr_Occurred()) SWIG_fail;
6164 }
6165 {
6166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6167 }
6168 return resultobj;
6169 fail:
6170 return NULL;
6171 }
6172
6173
6174 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6175 PyObject *resultobj = NULL;
6176 wxRect *arg1 = (wxRect *) 0 ;
6177 wxRect *arg2 = 0 ;
6178 bool result;
6179 wxRect temp2 ;
6180 PyObject * obj0 = 0 ;
6181 PyObject * obj1 = 0 ;
6182 char *kwnames[] = {
6183 (char *) "self",(char *) "rect", NULL
6184 };
6185
6186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6188 if (SWIG_arg_fail(1)) SWIG_fail;
6189 {
6190 arg2 = &temp2;
6191 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6192 }
6193 {
6194 PyThreadState* __tstate = wxPyBeginAllowThreads();
6195 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6196
6197 wxPyEndAllowThreads(__tstate);
6198 if (PyErr_Occurred()) SWIG_fail;
6199 }
6200 {
6201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6202 }
6203 return resultobj;
6204 fail:
6205 return NULL;
6206 }
6207
6208
6209 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6210 PyObject *resultobj = NULL;
6211 wxRect *arg1 = (wxRect *) 0 ;
6212 int arg2 ;
6213 int arg3 ;
6214 bool result;
6215 PyObject * obj0 = 0 ;
6216 PyObject * obj1 = 0 ;
6217 PyObject * obj2 = 0 ;
6218 char *kwnames[] = {
6219 (char *) "self",(char *) "x",(char *) "y", NULL
6220 };
6221
6222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6224 if (SWIG_arg_fail(1)) SWIG_fail;
6225 {
6226 arg2 = static_cast<int >(SWIG_As_int(obj1));
6227 if (SWIG_arg_fail(2)) SWIG_fail;
6228 }
6229 {
6230 arg3 = static_cast<int >(SWIG_As_int(obj2));
6231 if (SWIG_arg_fail(3)) SWIG_fail;
6232 }
6233 {
6234 PyThreadState* __tstate = wxPyBeginAllowThreads();
6235 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6236
6237 wxPyEndAllowThreads(__tstate);
6238 if (PyErr_Occurred()) SWIG_fail;
6239 }
6240 {
6241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6242 }
6243 return resultobj;
6244 fail:
6245 return NULL;
6246 }
6247
6248
6249 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6250 PyObject *resultobj = NULL;
6251 wxRect *arg1 = (wxRect *) 0 ;
6252 wxPoint *arg2 = 0 ;
6253 bool result;
6254 wxPoint temp2 ;
6255 PyObject * obj0 = 0 ;
6256 PyObject * obj1 = 0 ;
6257 char *kwnames[] = {
6258 (char *) "self",(char *) "pt", NULL
6259 };
6260
6261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6263 if (SWIG_arg_fail(1)) SWIG_fail;
6264 {
6265 arg2 = &temp2;
6266 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6267 }
6268 {
6269 PyThreadState* __tstate = wxPyBeginAllowThreads();
6270 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6271
6272 wxPyEndAllowThreads(__tstate);
6273 if (PyErr_Occurred()) SWIG_fail;
6274 }
6275 {
6276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6277 }
6278 return resultobj;
6279 fail:
6280 return NULL;
6281 }
6282
6283
6284 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6285 PyObject *resultobj = NULL;
6286 wxRect *arg1 = (wxRect *) 0 ;
6287 wxRect *arg2 = 0 ;
6288 bool result;
6289 wxRect temp2 ;
6290 PyObject * obj0 = 0 ;
6291 PyObject * obj1 = 0 ;
6292 char *kwnames[] = {
6293 (char *) "self",(char *) "rect", NULL
6294 };
6295
6296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6298 if (SWIG_arg_fail(1)) SWIG_fail;
6299 {
6300 arg2 = &temp2;
6301 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6302 }
6303 {
6304 PyThreadState* __tstate = wxPyBeginAllowThreads();
6305 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6306
6307 wxPyEndAllowThreads(__tstate);
6308 if (PyErr_Occurred()) SWIG_fail;
6309 }
6310 {
6311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6312 }
6313 return resultobj;
6314 fail:
6315 return NULL;
6316 }
6317
6318
6319 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6320 PyObject *resultobj = NULL;
6321 wxRect *arg1 = (wxRect *) 0 ;
6322 int arg2 ;
6323 PyObject * obj0 = 0 ;
6324 PyObject * obj1 = 0 ;
6325 char *kwnames[] = {
6326 (char *) "self",(char *) "x", NULL
6327 };
6328
6329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6331 if (SWIG_arg_fail(1)) SWIG_fail;
6332 {
6333 arg2 = static_cast<int >(SWIG_As_int(obj1));
6334 if (SWIG_arg_fail(2)) SWIG_fail;
6335 }
6336 if (arg1) (arg1)->x = arg2;
6337
6338 Py_INCREF(Py_None); resultobj = Py_None;
6339 return resultobj;
6340 fail:
6341 return NULL;
6342 }
6343
6344
6345 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6346 PyObject *resultobj = NULL;
6347 wxRect *arg1 = (wxRect *) 0 ;
6348 int result;
6349 PyObject * obj0 = 0 ;
6350 char *kwnames[] = {
6351 (char *) "self", NULL
6352 };
6353
6354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6356 if (SWIG_arg_fail(1)) SWIG_fail;
6357 result = (int) ((arg1)->x);
6358
6359 {
6360 resultobj = SWIG_From_int(static_cast<int >(result));
6361 }
6362 return resultobj;
6363 fail:
6364 return NULL;
6365 }
6366
6367
6368 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6369 PyObject *resultobj = NULL;
6370 wxRect *arg1 = (wxRect *) 0 ;
6371 int arg2 ;
6372 PyObject * obj0 = 0 ;
6373 PyObject * obj1 = 0 ;
6374 char *kwnames[] = {
6375 (char *) "self",(char *) "y", NULL
6376 };
6377
6378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6380 if (SWIG_arg_fail(1)) SWIG_fail;
6381 {
6382 arg2 = static_cast<int >(SWIG_As_int(obj1));
6383 if (SWIG_arg_fail(2)) SWIG_fail;
6384 }
6385 if (arg1) (arg1)->y = arg2;
6386
6387 Py_INCREF(Py_None); resultobj = Py_None;
6388 return resultobj;
6389 fail:
6390 return NULL;
6391 }
6392
6393
6394 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6395 PyObject *resultobj = NULL;
6396 wxRect *arg1 = (wxRect *) 0 ;
6397 int result;
6398 PyObject * obj0 = 0 ;
6399 char *kwnames[] = {
6400 (char *) "self", NULL
6401 };
6402
6403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6405 if (SWIG_arg_fail(1)) SWIG_fail;
6406 result = (int) ((arg1)->y);
6407
6408 {
6409 resultobj = SWIG_From_int(static_cast<int >(result));
6410 }
6411 return resultobj;
6412 fail:
6413 return NULL;
6414 }
6415
6416
6417 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6418 PyObject *resultobj = NULL;
6419 wxRect *arg1 = (wxRect *) 0 ;
6420 int arg2 ;
6421 PyObject * obj0 = 0 ;
6422 PyObject * obj1 = 0 ;
6423 char *kwnames[] = {
6424 (char *) "self",(char *) "width", NULL
6425 };
6426
6427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6429 if (SWIG_arg_fail(1)) SWIG_fail;
6430 {
6431 arg2 = static_cast<int >(SWIG_As_int(obj1));
6432 if (SWIG_arg_fail(2)) SWIG_fail;
6433 }
6434 if (arg1) (arg1)->width = arg2;
6435
6436 Py_INCREF(Py_None); resultobj = Py_None;
6437 return resultobj;
6438 fail:
6439 return NULL;
6440 }
6441
6442
6443 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6444 PyObject *resultobj = NULL;
6445 wxRect *arg1 = (wxRect *) 0 ;
6446 int result;
6447 PyObject * obj0 = 0 ;
6448 char *kwnames[] = {
6449 (char *) "self", NULL
6450 };
6451
6452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6454 if (SWIG_arg_fail(1)) SWIG_fail;
6455 result = (int) ((arg1)->width);
6456
6457 {
6458 resultobj = SWIG_From_int(static_cast<int >(result));
6459 }
6460 return resultobj;
6461 fail:
6462 return NULL;
6463 }
6464
6465
6466 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6467 PyObject *resultobj = NULL;
6468 wxRect *arg1 = (wxRect *) 0 ;
6469 int arg2 ;
6470 PyObject * obj0 = 0 ;
6471 PyObject * obj1 = 0 ;
6472 char *kwnames[] = {
6473 (char *) "self",(char *) "height", NULL
6474 };
6475
6476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6478 if (SWIG_arg_fail(1)) SWIG_fail;
6479 {
6480 arg2 = static_cast<int >(SWIG_As_int(obj1));
6481 if (SWIG_arg_fail(2)) SWIG_fail;
6482 }
6483 if (arg1) (arg1)->height = arg2;
6484
6485 Py_INCREF(Py_None); resultobj = Py_None;
6486 return resultobj;
6487 fail:
6488 return NULL;
6489 }
6490
6491
6492 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6493 PyObject *resultobj = NULL;
6494 wxRect *arg1 = (wxRect *) 0 ;
6495 int result;
6496 PyObject * obj0 = 0 ;
6497 char *kwnames[] = {
6498 (char *) "self", NULL
6499 };
6500
6501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6503 if (SWIG_arg_fail(1)) SWIG_fail;
6504 result = (int) ((arg1)->height);
6505
6506 {
6507 resultobj = SWIG_From_int(static_cast<int >(result));
6508 }
6509 return resultobj;
6510 fail:
6511 return NULL;
6512 }
6513
6514
6515 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6516 PyObject *resultobj = NULL;
6517 wxRect *arg1 = (wxRect *) 0 ;
6518 int arg2 = (int) 0 ;
6519 int arg3 = (int) 0 ;
6520 int arg4 = (int) 0 ;
6521 int arg5 = (int) 0 ;
6522 PyObject * obj0 = 0 ;
6523 PyObject * obj1 = 0 ;
6524 PyObject * obj2 = 0 ;
6525 PyObject * obj3 = 0 ;
6526 PyObject * obj4 = 0 ;
6527 char *kwnames[] = {
6528 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6529 };
6530
6531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6533 if (SWIG_arg_fail(1)) SWIG_fail;
6534 if (obj1) {
6535 {
6536 arg2 = static_cast<int >(SWIG_As_int(obj1));
6537 if (SWIG_arg_fail(2)) SWIG_fail;
6538 }
6539 }
6540 if (obj2) {
6541 {
6542 arg3 = static_cast<int >(SWIG_As_int(obj2));
6543 if (SWIG_arg_fail(3)) SWIG_fail;
6544 }
6545 }
6546 if (obj3) {
6547 {
6548 arg4 = static_cast<int >(SWIG_As_int(obj3));
6549 if (SWIG_arg_fail(4)) SWIG_fail;
6550 }
6551 }
6552 if (obj4) {
6553 {
6554 arg5 = static_cast<int >(SWIG_As_int(obj4));
6555 if (SWIG_arg_fail(5)) SWIG_fail;
6556 }
6557 }
6558 {
6559 PyThreadState* __tstate = wxPyBeginAllowThreads();
6560 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6561
6562 wxPyEndAllowThreads(__tstate);
6563 if (PyErr_Occurred()) SWIG_fail;
6564 }
6565 Py_INCREF(Py_None); resultobj = Py_None;
6566 return resultobj;
6567 fail:
6568 return NULL;
6569 }
6570
6571
6572 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6573 PyObject *resultobj = NULL;
6574 wxRect *arg1 = (wxRect *) 0 ;
6575 PyObject *result;
6576 PyObject * obj0 = 0 ;
6577 char *kwnames[] = {
6578 (char *) "self", NULL
6579 };
6580
6581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6583 if (SWIG_arg_fail(1)) SWIG_fail;
6584 {
6585 PyThreadState* __tstate = wxPyBeginAllowThreads();
6586 result = (PyObject *)wxRect_Get(arg1);
6587
6588 wxPyEndAllowThreads(__tstate);
6589 if (PyErr_Occurred()) SWIG_fail;
6590 }
6591 resultobj = result;
6592 return resultobj;
6593 fail:
6594 return NULL;
6595 }
6596
6597
6598 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6599 PyObject *obj;
6600 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6601 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6602 Py_INCREF(obj);
6603 return Py_BuildValue((char *)"");
6604 }
6605 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6606 PyObject *resultobj = NULL;
6607 wxRect *arg1 = (wxRect *) 0 ;
6608 wxRect *arg2 = (wxRect *) 0 ;
6609 PyObject *result;
6610 PyObject * obj0 = 0 ;
6611 PyObject * obj1 = 0 ;
6612 char *kwnames[] = {
6613 (char *) "r1",(char *) "r2", NULL
6614 };
6615
6616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6618 if (SWIG_arg_fail(1)) SWIG_fail;
6619 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6620 if (SWIG_arg_fail(2)) SWIG_fail;
6621 {
6622 if (!wxPyCheckForApp()) SWIG_fail;
6623 PyThreadState* __tstate = wxPyBeginAllowThreads();
6624 result = (PyObject *)wxIntersectRect(arg1,arg2);
6625
6626 wxPyEndAllowThreads(__tstate);
6627 if (PyErr_Occurred()) SWIG_fail;
6628 }
6629 resultobj = result;
6630 return resultobj;
6631 fail:
6632 return NULL;
6633 }
6634
6635
6636 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6637 PyObject *resultobj = NULL;
6638 double arg1 = (double) 0.0 ;
6639 double arg2 = (double) 0.0 ;
6640 wxPoint2D *result;
6641 PyObject * obj0 = 0 ;
6642 PyObject * obj1 = 0 ;
6643 char *kwnames[] = {
6644 (char *) "x",(char *) "y", NULL
6645 };
6646
6647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6648 if (obj0) {
6649 {
6650 arg1 = static_cast<double >(SWIG_As_double(obj0));
6651 if (SWIG_arg_fail(1)) SWIG_fail;
6652 }
6653 }
6654 if (obj1) {
6655 {
6656 arg2 = static_cast<double >(SWIG_As_double(obj1));
6657 if (SWIG_arg_fail(2)) SWIG_fail;
6658 }
6659 }
6660 {
6661 PyThreadState* __tstate = wxPyBeginAllowThreads();
6662 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6663
6664 wxPyEndAllowThreads(__tstate);
6665 if (PyErr_Occurred()) SWIG_fail;
6666 }
6667 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6668 return resultobj;
6669 fail:
6670 return NULL;
6671 }
6672
6673
6674 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6675 PyObject *resultobj = NULL;
6676 wxPoint2D *arg1 = 0 ;
6677 wxPoint2D *result;
6678 wxPoint2D temp1 ;
6679 PyObject * obj0 = 0 ;
6680 char *kwnames[] = {
6681 (char *) "pt", NULL
6682 };
6683
6684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6685 {
6686 arg1 = &temp1;
6687 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6688 }
6689 {
6690 PyThreadState* __tstate = wxPyBeginAllowThreads();
6691 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6692
6693 wxPyEndAllowThreads(__tstate);
6694 if (PyErr_Occurred()) SWIG_fail;
6695 }
6696 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6697 return resultobj;
6698 fail:
6699 return NULL;
6700 }
6701
6702
6703 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6704 PyObject *resultobj = NULL;
6705 wxPoint *arg1 = 0 ;
6706 wxPoint2D *result;
6707 wxPoint temp1 ;
6708 PyObject * obj0 = 0 ;
6709 char *kwnames[] = {
6710 (char *) "pt", NULL
6711 };
6712
6713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6714 {
6715 arg1 = &temp1;
6716 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6717 }
6718 {
6719 PyThreadState* __tstate = wxPyBeginAllowThreads();
6720 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6721
6722 wxPyEndAllowThreads(__tstate);
6723 if (PyErr_Occurred()) SWIG_fail;
6724 }
6725 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6726 return resultobj;
6727 fail:
6728 return NULL;
6729 }
6730
6731
6732 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6733 PyObject *resultobj = NULL;
6734 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6735 int *arg2 = (int *) 0 ;
6736 int *arg3 = (int *) 0 ;
6737 int temp2 ;
6738 int res2 = 0 ;
6739 int temp3 ;
6740 int res3 = 0 ;
6741 PyObject * obj0 = 0 ;
6742 char *kwnames[] = {
6743 (char *) "self", NULL
6744 };
6745
6746 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6747 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6750 if (SWIG_arg_fail(1)) SWIG_fail;
6751 {
6752 PyThreadState* __tstate = wxPyBeginAllowThreads();
6753 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6754
6755 wxPyEndAllowThreads(__tstate);
6756 if (PyErr_Occurred()) SWIG_fail;
6757 }
6758 Py_INCREF(Py_None); resultobj = Py_None;
6759 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6760 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6761 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6762 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6763 return resultobj;
6764 fail:
6765 return NULL;
6766 }
6767
6768
6769 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6770 PyObject *resultobj = NULL;
6771 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6772 int *arg2 = (int *) 0 ;
6773 int *arg3 = (int *) 0 ;
6774 int temp2 ;
6775 int res2 = 0 ;
6776 int temp3 ;
6777 int res3 = 0 ;
6778 PyObject * obj0 = 0 ;
6779 char *kwnames[] = {
6780 (char *) "self", NULL
6781 };
6782
6783 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6784 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6787 if (SWIG_arg_fail(1)) SWIG_fail;
6788 {
6789 PyThreadState* __tstate = wxPyBeginAllowThreads();
6790 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6791
6792 wxPyEndAllowThreads(__tstate);
6793 if (PyErr_Occurred()) SWIG_fail;
6794 }
6795 Py_INCREF(Py_None); resultobj = Py_None;
6796 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6797 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6798 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6799 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6800 return resultobj;
6801 fail:
6802 return NULL;
6803 }
6804
6805
6806 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6807 PyObject *resultobj = NULL;
6808 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6809 double result;
6810 PyObject * obj0 = 0 ;
6811 char *kwnames[] = {
6812 (char *) "self", NULL
6813 };
6814
6815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6817 if (SWIG_arg_fail(1)) SWIG_fail;
6818 {
6819 PyThreadState* __tstate = wxPyBeginAllowThreads();
6820 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6821
6822 wxPyEndAllowThreads(__tstate);
6823 if (PyErr_Occurred()) SWIG_fail;
6824 }
6825 {
6826 resultobj = SWIG_From_double(static_cast<double >(result));
6827 }
6828 return resultobj;
6829 fail:
6830 return NULL;
6831 }
6832
6833
6834 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6835 PyObject *resultobj = NULL;
6836 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6837 double result;
6838 PyObject * obj0 = 0 ;
6839 char *kwnames[] = {
6840 (char *) "self", NULL
6841 };
6842
6843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6845 if (SWIG_arg_fail(1)) SWIG_fail;
6846 {
6847 PyThreadState* __tstate = wxPyBeginAllowThreads();
6848 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6849
6850 wxPyEndAllowThreads(__tstate);
6851 if (PyErr_Occurred()) SWIG_fail;
6852 }
6853 {
6854 resultobj = SWIG_From_double(static_cast<double >(result));
6855 }
6856 return resultobj;
6857 fail:
6858 return NULL;
6859 }
6860
6861
6862 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6863 PyObject *resultobj = NULL;
6864 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6865 double arg2 ;
6866 PyObject * obj0 = 0 ;
6867 PyObject * obj1 = 0 ;
6868 char *kwnames[] = {
6869 (char *) "self",(char *) "length", NULL
6870 };
6871
6872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6874 if (SWIG_arg_fail(1)) SWIG_fail;
6875 {
6876 arg2 = static_cast<double >(SWIG_As_double(obj1));
6877 if (SWIG_arg_fail(2)) SWIG_fail;
6878 }
6879 {
6880 PyThreadState* __tstate = wxPyBeginAllowThreads();
6881 (arg1)->SetVectorLength(arg2);
6882
6883 wxPyEndAllowThreads(__tstate);
6884 if (PyErr_Occurred()) SWIG_fail;
6885 }
6886 Py_INCREF(Py_None); resultobj = Py_None;
6887 return resultobj;
6888 fail:
6889 return NULL;
6890 }
6891
6892
6893 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6894 PyObject *resultobj = NULL;
6895 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6896 double arg2 ;
6897 PyObject * obj0 = 0 ;
6898 PyObject * obj1 = 0 ;
6899 char *kwnames[] = {
6900 (char *) "self",(char *) "degrees", NULL
6901 };
6902
6903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6905 if (SWIG_arg_fail(1)) SWIG_fail;
6906 {
6907 arg2 = static_cast<double >(SWIG_As_double(obj1));
6908 if (SWIG_arg_fail(2)) SWIG_fail;
6909 }
6910 {
6911 PyThreadState* __tstate = wxPyBeginAllowThreads();
6912 (arg1)->SetVectorAngle(arg2);
6913
6914 wxPyEndAllowThreads(__tstate);
6915 if (PyErr_Occurred()) SWIG_fail;
6916 }
6917 Py_INCREF(Py_None); resultobj = Py_None;
6918 return resultobj;
6919 fail:
6920 return NULL;
6921 }
6922
6923
6924 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6925 PyObject *resultobj = NULL;
6926 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6927 wxPoint2D *arg2 = 0 ;
6928 double result;
6929 wxPoint2D temp2 ;
6930 PyObject * obj0 = 0 ;
6931 PyObject * obj1 = 0 ;
6932 char *kwnames[] = {
6933 (char *) "self",(char *) "pt", NULL
6934 };
6935
6936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6938 if (SWIG_arg_fail(1)) SWIG_fail;
6939 {
6940 arg2 = &temp2;
6941 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6942 }
6943 {
6944 PyThreadState* __tstate = wxPyBeginAllowThreads();
6945 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6946
6947 wxPyEndAllowThreads(__tstate);
6948 if (PyErr_Occurred()) SWIG_fail;
6949 }
6950 {
6951 resultobj = SWIG_From_double(static_cast<double >(result));
6952 }
6953 return resultobj;
6954 fail:
6955 return NULL;
6956 }
6957
6958
6959 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6960 PyObject *resultobj = NULL;
6961 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6962 wxPoint2D *arg2 = 0 ;
6963 double result;
6964 wxPoint2D temp2 ;
6965 PyObject * obj0 = 0 ;
6966 PyObject * obj1 = 0 ;
6967 char *kwnames[] = {
6968 (char *) "self",(char *) "pt", NULL
6969 };
6970
6971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6973 if (SWIG_arg_fail(1)) SWIG_fail;
6974 {
6975 arg2 = &temp2;
6976 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6977 }
6978 {
6979 PyThreadState* __tstate = wxPyBeginAllowThreads();
6980 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6981
6982 wxPyEndAllowThreads(__tstate);
6983 if (PyErr_Occurred()) SWIG_fail;
6984 }
6985 {
6986 resultobj = SWIG_From_double(static_cast<double >(result));
6987 }
6988 return resultobj;
6989 fail:
6990 return NULL;
6991 }
6992
6993
6994 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6995 PyObject *resultobj = NULL;
6996 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6997 wxPoint2D *arg2 = 0 ;
6998 double result;
6999 wxPoint2D temp2 ;
7000 PyObject * obj0 = 0 ;
7001 PyObject * obj1 = 0 ;
7002 char *kwnames[] = {
7003 (char *) "self",(char *) "vec", NULL
7004 };
7005
7006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
7007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7008 if (SWIG_arg_fail(1)) SWIG_fail;
7009 {
7010 arg2 = &temp2;
7011 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7012 }
7013 {
7014 PyThreadState* __tstate = wxPyBeginAllowThreads();
7015 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
7016
7017 wxPyEndAllowThreads(__tstate);
7018 if (PyErr_Occurred()) SWIG_fail;
7019 }
7020 {
7021 resultobj = SWIG_From_double(static_cast<double >(result));
7022 }
7023 return resultobj;
7024 fail:
7025 return NULL;
7026 }
7027
7028
7029 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
7030 PyObject *resultobj = NULL;
7031 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7032 wxPoint2D *arg2 = 0 ;
7033 double result;
7034 wxPoint2D temp2 ;
7035 PyObject * obj0 = 0 ;
7036 PyObject * obj1 = 0 ;
7037 char *kwnames[] = {
7038 (char *) "self",(char *) "vec", NULL
7039 };
7040
7041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
7042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7043 if (SWIG_arg_fail(1)) SWIG_fail;
7044 {
7045 arg2 = &temp2;
7046 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7047 }
7048 {
7049 PyThreadState* __tstate = wxPyBeginAllowThreads();
7050 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
7051
7052 wxPyEndAllowThreads(__tstate);
7053 if (PyErr_Occurred()) SWIG_fail;
7054 }
7055 {
7056 resultobj = SWIG_From_double(static_cast<double >(result));
7057 }
7058 return resultobj;
7059 fail:
7060 return NULL;
7061 }
7062
7063
7064 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
7065 PyObject *resultobj = NULL;
7066 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7067 wxPoint2D result;
7068 PyObject * obj0 = 0 ;
7069 char *kwnames[] = {
7070 (char *) "self", NULL
7071 };
7072
7073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
7074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7075 if (SWIG_arg_fail(1)) SWIG_fail;
7076 {
7077 PyThreadState* __tstate = wxPyBeginAllowThreads();
7078 result = (arg1)->operator -();
7079
7080 wxPyEndAllowThreads(__tstate);
7081 if (PyErr_Occurred()) SWIG_fail;
7082 }
7083 {
7084 wxPoint2D * resultptr;
7085 resultptr = new wxPoint2D(static_cast<wxPoint2D & >(result));
7086 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
7087 }
7088 return resultobj;
7089 fail:
7090 return NULL;
7091 }
7092
7093
7094 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
7095 PyObject *resultobj = NULL;
7096 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7097 wxPoint2D *arg2 = 0 ;
7098 wxPoint2D *result;
7099 wxPoint2D temp2 ;
7100 PyObject * obj0 = 0 ;
7101 PyObject * obj1 = 0 ;
7102 char *kwnames[] = {
7103 (char *) "self",(char *) "pt", NULL
7104 };
7105
7106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
7107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7108 if (SWIG_arg_fail(1)) SWIG_fail;
7109 {
7110 arg2 = &temp2;
7111 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7112 }
7113 {
7114 PyThreadState* __tstate = wxPyBeginAllowThreads();
7115 {
7116 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
7117 result = (wxPoint2D *) &_result_ref;
7118 }
7119
7120 wxPyEndAllowThreads(__tstate);
7121 if (PyErr_Occurred()) SWIG_fail;
7122 }
7123 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7124 return resultobj;
7125 fail:
7126 return NULL;
7127 }
7128
7129
7130 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
7131 PyObject *resultobj = NULL;
7132 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7133 wxPoint2D *arg2 = 0 ;
7134 wxPoint2D *result;
7135 wxPoint2D temp2 ;
7136 PyObject * obj0 = 0 ;
7137 PyObject * obj1 = 0 ;
7138 char *kwnames[] = {
7139 (char *) "self",(char *) "pt", NULL
7140 };
7141
7142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7144 if (SWIG_arg_fail(1)) SWIG_fail;
7145 {
7146 arg2 = &temp2;
7147 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7148 }
7149 {
7150 PyThreadState* __tstate = wxPyBeginAllowThreads();
7151 {
7152 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7153 result = (wxPoint2D *) &_result_ref;
7154 }
7155
7156 wxPyEndAllowThreads(__tstate);
7157 if (PyErr_Occurred()) SWIG_fail;
7158 }
7159 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7160 return resultobj;
7161 fail:
7162 return NULL;
7163 }
7164
7165
7166 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7167 PyObject *resultobj = NULL;
7168 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7169 wxPoint2D *arg2 = 0 ;
7170 wxPoint2D *result;
7171 wxPoint2D temp2 ;
7172 PyObject * obj0 = 0 ;
7173 PyObject * obj1 = 0 ;
7174 char *kwnames[] = {
7175 (char *) "self",(char *) "pt", NULL
7176 };
7177
7178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7180 if (SWIG_arg_fail(1)) SWIG_fail;
7181 {
7182 arg2 = &temp2;
7183 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7184 }
7185 {
7186 PyThreadState* __tstate = wxPyBeginAllowThreads();
7187 {
7188 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7189 result = (wxPoint2D *) &_result_ref;
7190 }
7191
7192 wxPyEndAllowThreads(__tstate);
7193 if (PyErr_Occurred()) SWIG_fail;
7194 }
7195 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7196 return resultobj;
7197 fail:
7198 return NULL;
7199 }
7200
7201
7202 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7203 PyObject *resultobj = NULL;
7204 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7205 wxPoint2D *arg2 = 0 ;
7206 wxPoint2D *result;
7207 wxPoint2D temp2 ;
7208 PyObject * obj0 = 0 ;
7209 PyObject * obj1 = 0 ;
7210 char *kwnames[] = {
7211 (char *) "self",(char *) "pt", NULL
7212 };
7213
7214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7216 if (SWIG_arg_fail(1)) SWIG_fail;
7217 {
7218 arg2 = &temp2;
7219 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7220 }
7221 {
7222 PyThreadState* __tstate = wxPyBeginAllowThreads();
7223 {
7224 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7225 result = (wxPoint2D *) &_result_ref;
7226 }
7227
7228 wxPyEndAllowThreads(__tstate);
7229 if (PyErr_Occurred()) SWIG_fail;
7230 }
7231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7232 return resultobj;
7233 fail:
7234 return NULL;
7235 }
7236
7237
7238 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7239 PyObject *resultobj = NULL;
7240 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7241 wxPoint2D *arg2 = 0 ;
7242 bool result;
7243 wxPoint2D temp2 ;
7244 PyObject * obj0 = 0 ;
7245 PyObject * obj1 = 0 ;
7246 char *kwnames[] = {
7247 (char *) "self",(char *) "pt", NULL
7248 };
7249
7250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7252 if (SWIG_arg_fail(1)) SWIG_fail;
7253 {
7254 arg2 = &temp2;
7255 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7256 }
7257 {
7258 PyThreadState* __tstate = wxPyBeginAllowThreads();
7259 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7260
7261 wxPyEndAllowThreads(__tstate);
7262 if (PyErr_Occurred()) SWIG_fail;
7263 }
7264 {
7265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7266 }
7267 return resultobj;
7268 fail:
7269 return NULL;
7270 }
7271
7272
7273 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7274 PyObject *resultobj = NULL;
7275 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7276 wxPoint2D *arg2 = 0 ;
7277 bool result;
7278 wxPoint2D temp2 ;
7279 PyObject * obj0 = 0 ;
7280 PyObject * obj1 = 0 ;
7281 char *kwnames[] = {
7282 (char *) "self",(char *) "pt", NULL
7283 };
7284
7285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7287 if (SWIG_arg_fail(1)) SWIG_fail;
7288 {
7289 arg2 = &temp2;
7290 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7291 }
7292 {
7293 PyThreadState* __tstate = wxPyBeginAllowThreads();
7294 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7295
7296 wxPyEndAllowThreads(__tstate);
7297 if (PyErr_Occurred()) SWIG_fail;
7298 }
7299 {
7300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7301 }
7302 return resultobj;
7303 fail:
7304 return NULL;
7305 }
7306
7307
7308 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7309 PyObject *resultobj = NULL;
7310 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7311 double arg2 ;
7312 PyObject * obj0 = 0 ;
7313 PyObject * obj1 = 0 ;
7314 char *kwnames[] = {
7315 (char *) "self",(char *) "m_x", NULL
7316 };
7317
7318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7320 if (SWIG_arg_fail(1)) SWIG_fail;
7321 {
7322 arg2 = static_cast<double >(SWIG_As_double(obj1));
7323 if (SWIG_arg_fail(2)) SWIG_fail;
7324 }
7325 if (arg1) (arg1)->m_x = arg2;
7326
7327 Py_INCREF(Py_None); resultobj = Py_None;
7328 return resultobj;
7329 fail:
7330 return NULL;
7331 }
7332
7333
7334 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7335 PyObject *resultobj = NULL;
7336 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7337 double result;
7338 PyObject * obj0 = 0 ;
7339 char *kwnames[] = {
7340 (char *) "self", NULL
7341 };
7342
7343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7345 if (SWIG_arg_fail(1)) SWIG_fail;
7346 result = (double) ((arg1)->m_x);
7347
7348 {
7349 resultobj = SWIG_From_double(static_cast<double >(result));
7350 }
7351 return resultobj;
7352 fail:
7353 return NULL;
7354 }
7355
7356
7357 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7358 PyObject *resultobj = NULL;
7359 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7360 double arg2 ;
7361 PyObject * obj0 = 0 ;
7362 PyObject * obj1 = 0 ;
7363 char *kwnames[] = {
7364 (char *) "self",(char *) "m_y", NULL
7365 };
7366
7367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7369 if (SWIG_arg_fail(1)) SWIG_fail;
7370 {
7371 arg2 = static_cast<double >(SWIG_As_double(obj1));
7372 if (SWIG_arg_fail(2)) SWIG_fail;
7373 }
7374 if (arg1) (arg1)->m_y = arg2;
7375
7376 Py_INCREF(Py_None); resultobj = Py_None;
7377 return resultobj;
7378 fail:
7379 return NULL;
7380 }
7381
7382
7383 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7384 PyObject *resultobj = NULL;
7385 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7386 double result;
7387 PyObject * obj0 = 0 ;
7388 char *kwnames[] = {
7389 (char *) "self", NULL
7390 };
7391
7392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7394 if (SWIG_arg_fail(1)) SWIG_fail;
7395 result = (double) ((arg1)->m_y);
7396
7397 {
7398 resultobj = SWIG_From_double(static_cast<double >(result));
7399 }
7400 return resultobj;
7401 fail:
7402 return NULL;
7403 }
7404
7405
7406 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7407 PyObject *resultobj = NULL;
7408 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7409 double arg2 = (double) 0 ;
7410 double arg3 = (double) 0 ;
7411 PyObject * obj0 = 0 ;
7412 PyObject * obj1 = 0 ;
7413 PyObject * obj2 = 0 ;
7414 char *kwnames[] = {
7415 (char *) "self",(char *) "x",(char *) "y", NULL
7416 };
7417
7418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7420 if (SWIG_arg_fail(1)) SWIG_fail;
7421 if (obj1) {
7422 {
7423 arg2 = static_cast<double >(SWIG_As_double(obj1));
7424 if (SWIG_arg_fail(2)) SWIG_fail;
7425 }
7426 }
7427 if (obj2) {
7428 {
7429 arg3 = static_cast<double >(SWIG_As_double(obj2));
7430 if (SWIG_arg_fail(3)) SWIG_fail;
7431 }
7432 }
7433 {
7434 PyThreadState* __tstate = wxPyBeginAllowThreads();
7435 wxPoint2D_Set(arg1,arg2,arg3);
7436
7437 wxPyEndAllowThreads(__tstate);
7438 if (PyErr_Occurred()) SWIG_fail;
7439 }
7440 Py_INCREF(Py_None); resultobj = Py_None;
7441 return resultobj;
7442 fail:
7443 return NULL;
7444 }
7445
7446
7447 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7448 PyObject *resultobj = NULL;
7449 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7450 PyObject *result;
7451 PyObject * obj0 = 0 ;
7452 char *kwnames[] = {
7453 (char *) "self", NULL
7454 };
7455
7456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7458 if (SWIG_arg_fail(1)) SWIG_fail;
7459 {
7460 PyThreadState* __tstate = wxPyBeginAllowThreads();
7461 result = (PyObject *)wxPoint2D_Get(arg1);
7462
7463 wxPyEndAllowThreads(__tstate);
7464 if (PyErr_Occurred()) SWIG_fail;
7465 }
7466 resultobj = result;
7467 return resultobj;
7468 fail:
7469 return NULL;
7470 }
7471
7472
7473 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7474 PyObject *obj;
7475 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7476 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7477 Py_INCREF(obj);
7478 return Py_BuildValue((char *)"");
7479 }
7480 static int _wrap_DefaultPosition_set(PyObject *) {
7481 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7482 return 1;
7483 }
7484
7485
7486 static PyObject *_wrap_DefaultPosition_get(void) {
7487 PyObject *pyobj = NULL;
7488
7489 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7490 return pyobj;
7491 }
7492
7493
7494 static int _wrap_DefaultSize_set(PyObject *) {
7495 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7496 return 1;
7497 }
7498
7499
7500 static PyObject *_wrap_DefaultSize_get(void) {
7501 PyObject *pyobj = NULL;
7502
7503 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7504 return pyobj;
7505 }
7506
7507
7508 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7509 PyObject *resultobj = NULL;
7510 PyObject *arg1 = (PyObject *) 0 ;
7511 wxPyInputStream *result;
7512 PyObject * obj0 = 0 ;
7513 char *kwnames[] = {
7514 (char *) "p", NULL
7515 };
7516
7517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7518 arg1 = obj0;
7519 {
7520 PyThreadState* __tstate = wxPyBeginAllowThreads();
7521 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7522
7523 wxPyEndAllowThreads(__tstate);
7524 if (PyErr_Occurred()) SWIG_fail;
7525 }
7526 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7527 return resultobj;
7528 fail:
7529 return NULL;
7530 }
7531
7532
7533 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7534 PyObject *resultobj = NULL;
7535 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7536 PyObject * obj0 = 0 ;
7537 char *kwnames[] = {
7538 (char *) "self", NULL
7539 };
7540
7541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7543 if (SWIG_arg_fail(1)) SWIG_fail;
7544 {
7545 PyThreadState* __tstate = wxPyBeginAllowThreads();
7546 delete arg1;
7547
7548 wxPyEndAllowThreads(__tstate);
7549 if (PyErr_Occurred()) SWIG_fail;
7550 }
7551 Py_INCREF(Py_None); resultobj = Py_None;
7552 return resultobj;
7553 fail:
7554 return NULL;
7555 }
7556
7557
7558 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7559 PyObject *resultobj = NULL;
7560 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7561 PyObject * obj0 = 0 ;
7562 char *kwnames[] = {
7563 (char *) "self", NULL
7564 };
7565
7566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7568 if (SWIG_arg_fail(1)) SWIG_fail;
7569 {
7570 PyThreadState* __tstate = wxPyBeginAllowThreads();
7571 (arg1)->close();
7572
7573 wxPyEndAllowThreads(__tstate);
7574 if (PyErr_Occurred()) SWIG_fail;
7575 }
7576 Py_INCREF(Py_None); resultobj = Py_None;
7577 return resultobj;
7578 fail:
7579 return NULL;
7580 }
7581
7582
7583 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7584 PyObject *resultobj = NULL;
7585 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7586 PyObject * obj0 = 0 ;
7587 char *kwnames[] = {
7588 (char *) "self", NULL
7589 };
7590
7591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7593 if (SWIG_arg_fail(1)) SWIG_fail;
7594 {
7595 PyThreadState* __tstate = wxPyBeginAllowThreads();
7596 (arg1)->flush();
7597
7598 wxPyEndAllowThreads(__tstate);
7599 if (PyErr_Occurred()) SWIG_fail;
7600 }
7601 Py_INCREF(Py_None); resultobj = Py_None;
7602 return resultobj;
7603 fail:
7604 return NULL;
7605 }
7606
7607
7608 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7609 PyObject *resultobj = NULL;
7610 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7611 bool result;
7612 PyObject * obj0 = 0 ;
7613 char *kwnames[] = {
7614 (char *) "self", NULL
7615 };
7616
7617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7619 if (SWIG_arg_fail(1)) SWIG_fail;
7620 {
7621 PyThreadState* __tstate = wxPyBeginAllowThreads();
7622 result = (bool)(arg1)->eof();
7623
7624 wxPyEndAllowThreads(__tstate);
7625 if (PyErr_Occurred()) SWIG_fail;
7626 }
7627 {
7628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7629 }
7630 return resultobj;
7631 fail:
7632 return NULL;
7633 }
7634
7635
7636 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7637 PyObject *resultobj = NULL;
7638 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7639 int arg2 = (int) -1 ;
7640 PyObject *result;
7641 PyObject * obj0 = 0 ;
7642 PyObject * obj1 = 0 ;
7643 char *kwnames[] = {
7644 (char *) "self",(char *) "size", NULL
7645 };
7646
7647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7649 if (SWIG_arg_fail(1)) SWIG_fail;
7650 if (obj1) {
7651 {
7652 arg2 = static_cast<int >(SWIG_As_int(obj1));
7653 if (SWIG_arg_fail(2)) SWIG_fail;
7654 }
7655 }
7656 {
7657 PyThreadState* __tstate = wxPyBeginAllowThreads();
7658 result = (PyObject *)(arg1)->read(arg2);
7659
7660 wxPyEndAllowThreads(__tstate);
7661 if (PyErr_Occurred()) SWIG_fail;
7662 }
7663 resultobj = result;
7664 return resultobj;
7665 fail:
7666 return NULL;
7667 }
7668
7669
7670 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7671 PyObject *resultobj = NULL;
7672 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7673 int arg2 = (int) -1 ;
7674 PyObject *result;
7675 PyObject * obj0 = 0 ;
7676 PyObject * obj1 = 0 ;
7677 char *kwnames[] = {
7678 (char *) "self",(char *) "size", NULL
7679 };
7680
7681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7683 if (SWIG_arg_fail(1)) SWIG_fail;
7684 if (obj1) {
7685 {
7686 arg2 = static_cast<int >(SWIG_As_int(obj1));
7687 if (SWIG_arg_fail(2)) SWIG_fail;
7688 }
7689 }
7690 {
7691 PyThreadState* __tstate = wxPyBeginAllowThreads();
7692 result = (PyObject *)(arg1)->readline(arg2);
7693
7694 wxPyEndAllowThreads(__tstate);
7695 if (PyErr_Occurred()) SWIG_fail;
7696 }
7697 resultobj = result;
7698 return resultobj;
7699 fail:
7700 return NULL;
7701 }
7702
7703
7704 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7705 PyObject *resultobj = NULL;
7706 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7707 int arg2 = (int) -1 ;
7708 PyObject *result;
7709 PyObject * obj0 = 0 ;
7710 PyObject * obj1 = 0 ;
7711 char *kwnames[] = {
7712 (char *) "self",(char *) "sizehint", NULL
7713 };
7714
7715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7717 if (SWIG_arg_fail(1)) SWIG_fail;
7718 if (obj1) {
7719 {
7720 arg2 = static_cast<int >(SWIG_As_int(obj1));
7721 if (SWIG_arg_fail(2)) SWIG_fail;
7722 }
7723 }
7724 {
7725 PyThreadState* __tstate = wxPyBeginAllowThreads();
7726 result = (PyObject *)(arg1)->readlines(arg2);
7727
7728 wxPyEndAllowThreads(__tstate);
7729 if (PyErr_Occurred()) SWIG_fail;
7730 }
7731 resultobj = result;
7732 return resultobj;
7733 fail:
7734 return NULL;
7735 }
7736
7737
7738 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7739 PyObject *resultobj = NULL;
7740 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7741 int arg2 ;
7742 int arg3 = (int) 0 ;
7743 PyObject * obj0 = 0 ;
7744 PyObject * obj1 = 0 ;
7745 PyObject * obj2 = 0 ;
7746 char *kwnames[] = {
7747 (char *) "self",(char *) "offset",(char *) "whence", NULL
7748 };
7749
7750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7752 if (SWIG_arg_fail(1)) SWIG_fail;
7753 {
7754 arg2 = static_cast<int >(SWIG_As_int(obj1));
7755 if (SWIG_arg_fail(2)) SWIG_fail;
7756 }
7757 if (obj2) {
7758 {
7759 arg3 = static_cast<int >(SWIG_As_int(obj2));
7760 if (SWIG_arg_fail(3)) SWIG_fail;
7761 }
7762 }
7763 {
7764 PyThreadState* __tstate = wxPyBeginAllowThreads();
7765 (arg1)->seek(arg2,arg3);
7766
7767 wxPyEndAllowThreads(__tstate);
7768 if (PyErr_Occurred()) SWIG_fail;
7769 }
7770 Py_INCREF(Py_None); resultobj = Py_None;
7771 return resultobj;
7772 fail:
7773 return NULL;
7774 }
7775
7776
7777 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7778 PyObject *resultobj = NULL;
7779 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7780 int result;
7781 PyObject * obj0 = 0 ;
7782 char *kwnames[] = {
7783 (char *) "self", NULL
7784 };
7785
7786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7788 if (SWIG_arg_fail(1)) SWIG_fail;
7789 {
7790 PyThreadState* __tstate = wxPyBeginAllowThreads();
7791 result = (int)(arg1)->tell();
7792
7793 wxPyEndAllowThreads(__tstate);
7794 if (PyErr_Occurred()) SWIG_fail;
7795 }
7796 {
7797 resultobj = SWIG_From_int(static_cast<int >(result));
7798 }
7799 return resultobj;
7800 fail:
7801 return NULL;
7802 }
7803
7804
7805 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7806 PyObject *resultobj = NULL;
7807 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7808 char result;
7809 PyObject * obj0 = 0 ;
7810 char *kwnames[] = {
7811 (char *) "self", NULL
7812 };
7813
7814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7816 if (SWIG_arg_fail(1)) SWIG_fail;
7817 {
7818 PyThreadState* __tstate = wxPyBeginAllowThreads();
7819 result = (char)(arg1)->Peek();
7820
7821 wxPyEndAllowThreads(__tstate);
7822 if (PyErr_Occurred()) SWIG_fail;
7823 }
7824 {
7825 resultobj = SWIG_From_char(static_cast<char >(result));
7826 }
7827 return resultobj;
7828 fail:
7829 return NULL;
7830 }
7831
7832
7833 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7834 PyObject *resultobj = NULL;
7835 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7836 char result;
7837 PyObject * obj0 = 0 ;
7838 char *kwnames[] = {
7839 (char *) "self", NULL
7840 };
7841
7842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7844 if (SWIG_arg_fail(1)) SWIG_fail;
7845 {
7846 PyThreadState* __tstate = wxPyBeginAllowThreads();
7847 result = (char)(arg1)->GetC();
7848
7849 wxPyEndAllowThreads(__tstate);
7850 if (PyErr_Occurred()) SWIG_fail;
7851 }
7852 {
7853 resultobj = SWIG_From_char(static_cast<char >(result));
7854 }
7855 return resultobj;
7856 fail:
7857 return NULL;
7858 }
7859
7860
7861 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7862 PyObject *resultobj = NULL;
7863 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7864 size_t result;
7865 PyObject * obj0 = 0 ;
7866 char *kwnames[] = {
7867 (char *) "self", NULL
7868 };
7869
7870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7872 if (SWIG_arg_fail(1)) SWIG_fail;
7873 {
7874 PyThreadState* __tstate = wxPyBeginAllowThreads();
7875 result = (size_t)(arg1)->LastRead();
7876
7877 wxPyEndAllowThreads(__tstate);
7878 if (PyErr_Occurred()) SWIG_fail;
7879 }
7880 {
7881 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
7882 }
7883 return resultobj;
7884 fail:
7885 return NULL;
7886 }
7887
7888
7889 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7890 PyObject *resultobj = NULL;
7891 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7892 bool result;
7893 PyObject * obj0 = 0 ;
7894 char *kwnames[] = {
7895 (char *) "self", NULL
7896 };
7897
7898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7900 if (SWIG_arg_fail(1)) SWIG_fail;
7901 {
7902 PyThreadState* __tstate = wxPyBeginAllowThreads();
7903 result = (bool)(arg1)->CanRead();
7904
7905 wxPyEndAllowThreads(__tstate);
7906 if (PyErr_Occurred()) SWIG_fail;
7907 }
7908 {
7909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7910 }
7911 return resultobj;
7912 fail:
7913 return NULL;
7914 }
7915
7916
7917 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7918 PyObject *resultobj = NULL;
7919 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7920 bool result;
7921 PyObject * obj0 = 0 ;
7922 char *kwnames[] = {
7923 (char *) "self", NULL
7924 };
7925
7926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7928 if (SWIG_arg_fail(1)) SWIG_fail;
7929 {
7930 PyThreadState* __tstate = wxPyBeginAllowThreads();
7931 result = (bool)(arg1)->Eof();
7932
7933 wxPyEndAllowThreads(__tstate);
7934 if (PyErr_Occurred()) SWIG_fail;
7935 }
7936 {
7937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7938 }
7939 return resultobj;
7940 fail:
7941 return NULL;
7942 }
7943
7944
7945 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7946 PyObject *resultobj = NULL;
7947 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7948 char arg2 ;
7949 bool result;
7950 PyObject * obj0 = 0 ;
7951 PyObject * obj1 = 0 ;
7952 char *kwnames[] = {
7953 (char *) "self",(char *) "c", NULL
7954 };
7955
7956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7958 if (SWIG_arg_fail(1)) SWIG_fail;
7959 {
7960 arg2 = static_cast<char >(SWIG_As_char(obj1));
7961 if (SWIG_arg_fail(2)) SWIG_fail;
7962 }
7963 {
7964 PyThreadState* __tstate = wxPyBeginAllowThreads();
7965 result = (bool)(arg1)->Ungetch(arg2);
7966
7967 wxPyEndAllowThreads(__tstate);
7968 if (PyErr_Occurred()) SWIG_fail;
7969 }
7970 {
7971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7972 }
7973 return resultobj;
7974 fail:
7975 return NULL;
7976 }
7977
7978
7979 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7980 PyObject *resultobj = NULL;
7981 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7982 long arg2 ;
7983 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7984 long result;
7985 PyObject * obj0 = 0 ;
7986 PyObject * obj1 = 0 ;
7987 PyObject * obj2 = 0 ;
7988 char *kwnames[] = {
7989 (char *) "self",(char *) "pos",(char *) "mode", NULL
7990 };
7991
7992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7994 if (SWIG_arg_fail(1)) SWIG_fail;
7995 {
7996 arg2 = static_cast<long >(SWIG_As_long(obj1));
7997 if (SWIG_arg_fail(2)) SWIG_fail;
7998 }
7999 if (obj2) {
8000 {
8001 arg3 = static_cast<wxSeekMode >(SWIG_As_int(obj2));
8002 if (SWIG_arg_fail(3)) SWIG_fail;
8003 }
8004 }
8005 {
8006 PyThreadState* __tstate = wxPyBeginAllowThreads();
8007 result = (long)(arg1)->SeekI(arg2,arg3);
8008
8009 wxPyEndAllowThreads(__tstate);
8010 if (PyErr_Occurred()) SWIG_fail;
8011 }
8012 {
8013 resultobj = SWIG_From_long(static_cast<long >(result));
8014 }
8015 return resultobj;
8016 fail:
8017 return NULL;
8018 }
8019
8020
8021 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
8022 PyObject *resultobj = NULL;
8023 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8024 long result;
8025 PyObject * obj0 = 0 ;
8026 char *kwnames[] = {
8027 (char *) "self", NULL
8028 };
8029
8030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
8031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
8032 if (SWIG_arg_fail(1)) SWIG_fail;
8033 {
8034 PyThreadState* __tstate = wxPyBeginAllowThreads();
8035 result = (long)(arg1)->TellI();
8036
8037 wxPyEndAllowThreads(__tstate);
8038 if (PyErr_Occurred()) SWIG_fail;
8039 }
8040 {
8041 resultobj = SWIG_From_long(static_cast<long >(result));
8042 }
8043 return resultobj;
8044 fail:
8045 return NULL;
8046 }
8047
8048
8049 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
8050 PyObject *obj;
8051 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8052 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
8053 Py_INCREF(obj);
8054 return Py_BuildValue((char *)"");
8055 }
8056 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
8057 PyObject *resultobj = NULL;
8058 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
8059 PyObject *arg2 = (PyObject *) 0 ;
8060 PyObject * obj0 = 0 ;
8061 PyObject * obj1 = 0 ;
8062 char *kwnames[] = {
8063 (char *) "self",(char *) "obj", NULL
8064 };
8065
8066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
8067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
8068 if (SWIG_arg_fail(1)) SWIG_fail;
8069 arg2 = obj1;
8070 {
8071 PyThreadState* __tstate = wxPyBeginAllowThreads();
8072 wxOutputStream_write(arg1,arg2);
8073
8074 wxPyEndAllowThreads(__tstate);
8075 if (PyErr_Occurred()) SWIG_fail;
8076 }
8077 Py_INCREF(Py_None); resultobj = Py_None;
8078 return resultobj;
8079 fail:
8080 return NULL;
8081 }
8082
8083
8084 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
8085 PyObject *obj;
8086 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8087 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
8088 Py_INCREF(obj);
8089 return Py_BuildValue((char *)"");
8090 }
8091 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8092 PyObject *resultobj = NULL;
8093 wxInputStream *arg1 = (wxInputStream *) 0 ;
8094 wxString *arg2 = 0 ;
8095 wxString *arg3 = 0 ;
8096 wxString *arg4 = 0 ;
8097 wxDateTime arg5 ;
8098 wxFSFile *result;
8099 wxPyInputStream *temp1 ;
8100 bool temp2 = false ;
8101 bool temp3 = false ;
8102 bool temp4 = false ;
8103 PyObject * obj0 = 0 ;
8104 PyObject * obj1 = 0 ;
8105 PyObject * obj2 = 0 ;
8106 PyObject * obj3 = 0 ;
8107 PyObject * obj4 = 0 ;
8108 char *kwnames[] = {
8109 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
8110 };
8111
8112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
8113 {
8114 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
8115 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
8116 } else {
8117 PyErr_Clear(); // clear the failure of the wxPyConvert above
8118 arg1 = wxPyCBInputStream_create(obj0, true);
8119 if (arg1 == NULL) {
8120 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
8121 SWIG_fail;
8122 }
8123 }
8124 }
8125 {
8126 arg2 = wxString_in_helper(obj1);
8127 if (arg2 == NULL) SWIG_fail;
8128 temp2 = true;
8129 }
8130 {
8131 arg3 = wxString_in_helper(obj2);
8132 if (arg3 == NULL) SWIG_fail;
8133 temp3 = true;
8134 }
8135 {
8136 arg4 = wxString_in_helper(obj3);
8137 if (arg4 == NULL) SWIG_fail;
8138 temp4 = true;
8139 }
8140 {
8141 wxDateTime * argp;
8142 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8143 if (SWIG_arg_fail(5)) SWIG_fail;
8144 if (argp == NULL) {
8145 SWIG_null_ref("wxDateTime");
8146 }
8147 if (SWIG_arg_fail(5)) SWIG_fail;
8148 arg5 = *argp;
8149 }
8150 {
8151 PyThreadState* __tstate = wxPyBeginAllowThreads();
8152 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8153
8154 wxPyEndAllowThreads(__tstate);
8155 if (PyErr_Occurred()) SWIG_fail;
8156 }
8157 {
8158 resultobj = wxPyMake_wxObject(result, (bool)1);
8159 }
8160 {
8161 if (temp2)
8162 delete arg2;
8163 }
8164 {
8165 if (temp3)
8166 delete arg3;
8167 }
8168 {
8169 if (temp4)
8170 delete arg4;
8171 }
8172 return resultobj;
8173 fail:
8174 {
8175 if (temp2)
8176 delete arg2;
8177 }
8178 {
8179 if (temp3)
8180 delete arg3;
8181 }
8182 {
8183 if (temp4)
8184 delete arg4;
8185 }
8186 return NULL;
8187 }
8188
8189
8190 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8191 PyObject *resultobj = NULL;
8192 wxFSFile *arg1 = (wxFSFile *) 0 ;
8193 PyObject * obj0 = 0 ;
8194 char *kwnames[] = {
8195 (char *) "self", NULL
8196 };
8197
8198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8200 if (SWIG_arg_fail(1)) SWIG_fail;
8201 {
8202 PyThreadState* __tstate = wxPyBeginAllowThreads();
8203 delete arg1;
8204
8205 wxPyEndAllowThreads(__tstate);
8206 if (PyErr_Occurred()) SWIG_fail;
8207 }
8208 Py_INCREF(Py_None); resultobj = Py_None;
8209 return resultobj;
8210 fail:
8211 return NULL;
8212 }
8213
8214
8215 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8216 PyObject *resultobj = NULL;
8217 wxFSFile *arg1 = (wxFSFile *) 0 ;
8218 wxInputStream *result;
8219 PyObject * obj0 = 0 ;
8220 char *kwnames[] = {
8221 (char *) "self", NULL
8222 };
8223
8224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8226 if (SWIG_arg_fail(1)) SWIG_fail;
8227 {
8228 PyThreadState* __tstate = wxPyBeginAllowThreads();
8229 result = (wxInputStream *)(arg1)->GetStream();
8230
8231 wxPyEndAllowThreads(__tstate);
8232 if (PyErr_Occurred()) SWIG_fail;
8233 }
8234 {
8235 wxPyInputStream * _ptr = NULL;
8236
8237 if (result) {
8238 _ptr = new wxPyInputStream(result);
8239 }
8240 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8241 }
8242 return resultobj;
8243 fail:
8244 return NULL;
8245 }
8246
8247
8248 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8249 PyObject *resultobj = NULL;
8250 wxFSFile *arg1 = (wxFSFile *) 0 ;
8251 wxString *result;
8252 PyObject * obj0 = 0 ;
8253 char *kwnames[] = {
8254 (char *) "self", NULL
8255 };
8256
8257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8259 if (SWIG_arg_fail(1)) SWIG_fail;
8260 {
8261 PyThreadState* __tstate = wxPyBeginAllowThreads();
8262 {
8263 wxString const &_result_ref = (arg1)->GetMimeType();
8264 result = (wxString *) &_result_ref;
8265 }
8266
8267 wxPyEndAllowThreads(__tstate);
8268 if (PyErr_Occurred()) SWIG_fail;
8269 }
8270 {
8271 #if wxUSE_UNICODE
8272 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8273 #else
8274 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8275 #endif
8276 }
8277 return resultobj;
8278 fail:
8279 return NULL;
8280 }
8281
8282
8283 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8284 PyObject *resultobj = NULL;
8285 wxFSFile *arg1 = (wxFSFile *) 0 ;
8286 wxString *result;
8287 PyObject * obj0 = 0 ;
8288 char *kwnames[] = {
8289 (char *) "self", NULL
8290 };
8291
8292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8294 if (SWIG_arg_fail(1)) SWIG_fail;
8295 {
8296 PyThreadState* __tstate = wxPyBeginAllowThreads();
8297 {
8298 wxString const &_result_ref = (arg1)->GetLocation();
8299 result = (wxString *) &_result_ref;
8300 }
8301
8302 wxPyEndAllowThreads(__tstate);
8303 if (PyErr_Occurred()) SWIG_fail;
8304 }
8305 {
8306 #if wxUSE_UNICODE
8307 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8308 #else
8309 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8310 #endif
8311 }
8312 return resultobj;
8313 fail:
8314 return NULL;
8315 }
8316
8317
8318 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8319 PyObject *resultobj = NULL;
8320 wxFSFile *arg1 = (wxFSFile *) 0 ;
8321 wxString *result;
8322 PyObject * obj0 = 0 ;
8323 char *kwnames[] = {
8324 (char *) "self", NULL
8325 };
8326
8327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8329 if (SWIG_arg_fail(1)) SWIG_fail;
8330 {
8331 PyThreadState* __tstate = wxPyBeginAllowThreads();
8332 {
8333 wxString const &_result_ref = (arg1)->GetAnchor();
8334 result = (wxString *) &_result_ref;
8335 }
8336
8337 wxPyEndAllowThreads(__tstate);
8338 if (PyErr_Occurred()) SWIG_fail;
8339 }
8340 {
8341 #if wxUSE_UNICODE
8342 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8343 #else
8344 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8345 #endif
8346 }
8347 return resultobj;
8348 fail:
8349 return NULL;
8350 }
8351
8352
8353 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8354 PyObject *resultobj = NULL;
8355 wxFSFile *arg1 = (wxFSFile *) 0 ;
8356 wxDateTime result;
8357 PyObject * obj0 = 0 ;
8358 char *kwnames[] = {
8359 (char *) "self", NULL
8360 };
8361
8362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8364 if (SWIG_arg_fail(1)) SWIG_fail;
8365 {
8366 PyThreadState* __tstate = wxPyBeginAllowThreads();
8367 result = (arg1)->GetModificationTime();
8368
8369 wxPyEndAllowThreads(__tstate);
8370 if (PyErr_Occurred()) SWIG_fail;
8371 }
8372 {
8373 wxDateTime * resultptr;
8374 resultptr = new wxDateTime(static_cast<wxDateTime & >(result));
8375 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8376 }
8377 return resultobj;
8378 fail:
8379 return NULL;
8380 }
8381
8382
8383 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8384 PyObject *obj;
8385 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8386 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8387 Py_INCREF(obj);
8388 return Py_BuildValue((char *)"");
8389 }
8390 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8391 PyObject *obj;
8392 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8393 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8394 Py_INCREF(obj);
8395 return Py_BuildValue((char *)"");
8396 }
8397 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8398 PyObject *resultobj = NULL;
8399 wxPyFileSystemHandler *result;
8400 char *kwnames[] = {
8401 NULL
8402 };
8403
8404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8405 {
8406 PyThreadState* __tstate = wxPyBeginAllowThreads();
8407 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8408
8409 wxPyEndAllowThreads(__tstate);
8410 if (PyErr_Occurred()) SWIG_fail;
8411 }
8412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8413 return resultobj;
8414 fail:
8415 return NULL;
8416 }
8417
8418
8419 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8420 PyObject *resultobj = NULL;
8421 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8422 PyObject *arg2 = (PyObject *) 0 ;
8423 PyObject *arg3 = (PyObject *) 0 ;
8424 PyObject * obj0 = 0 ;
8425 PyObject * obj1 = 0 ;
8426 PyObject * obj2 = 0 ;
8427 char *kwnames[] = {
8428 (char *) "self",(char *) "self",(char *) "_class", NULL
8429 };
8430
8431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8433 if (SWIG_arg_fail(1)) SWIG_fail;
8434 arg2 = obj1;
8435 arg3 = obj2;
8436 {
8437 PyThreadState* __tstate = wxPyBeginAllowThreads();
8438 (arg1)->_setCallbackInfo(arg2,arg3);
8439
8440 wxPyEndAllowThreads(__tstate);
8441 if (PyErr_Occurred()) SWIG_fail;
8442 }
8443 Py_INCREF(Py_None); resultobj = Py_None;
8444 return resultobj;
8445 fail:
8446 return NULL;
8447 }
8448
8449
8450 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8451 PyObject *resultobj = NULL;
8452 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8453 wxString *arg2 = 0 ;
8454 bool result;
8455 bool temp2 = false ;
8456 PyObject * obj0 = 0 ;
8457 PyObject * obj1 = 0 ;
8458 char *kwnames[] = {
8459 (char *) "self",(char *) "location", NULL
8460 };
8461
8462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8464 if (SWIG_arg_fail(1)) SWIG_fail;
8465 {
8466 arg2 = wxString_in_helper(obj1);
8467 if (arg2 == NULL) SWIG_fail;
8468 temp2 = true;
8469 }
8470 {
8471 PyThreadState* __tstate = wxPyBeginAllowThreads();
8472 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8473
8474 wxPyEndAllowThreads(__tstate);
8475 if (PyErr_Occurred()) SWIG_fail;
8476 }
8477 {
8478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8479 }
8480 {
8481 if (temp2)
8482 delete arg2;
8483 }
8484 return resultobj;
8485 fail:
8486 {
8487 if (temp2)
8488 delete arg2;
8489 }
8490 return NULL;
8491 }
8492
8493
8494 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8495 PyObject *resultobj = NULL;
8496 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8497 wxFileSystem *arg2 = 0 ;
8498 wxString *arg3 = 0 ;
8499 wxFSFile *result;
8500 bool temp3 = false ;
8501 PyObject * obj0 = 0 ;
8502 PyObject * obj1 = 0 ;
8503 PyObject * obj2 = 0 ;
8504 char *kwnames[] = {
8505 (char *) "self",(char *) "fs",(char *) "location", NULL
8506 };
8507
8508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8510 if (SWIG_arg_fail(1)) SWIG_fail;
8511 {
8512 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8513 if (SWIG_arg_fail(2)) SWIG_fail;
8514 if (arg2 == NULL) {
8515 SWIG_null_ref("wxFileSystem");
8516 }
8517 if (SWIG_arg_fail(2)) SWIG_fail;
8518 }
8519 {
8520 arg3 = wxString_in_helper(obj2);
8521 if (arg3 == NULL) SWIG_fail;
8522 temp3 = true;
8523 }
8524 {
8525 PyThreadState* __tstate = wxPyBeginAllowThreads();
8526 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8527
8528 wxPyEndAllowThreads(__tstate);
8529 if (PyErr_Occurred()) SWIG_fail;
8530 }
8531 {
8532 resultobj = wxPyMake_wxObject(result, (bool)1);
8533 }
8534 {
8535 if (temp3)
8536 delete arg3;
8537 }
8538 return resultobj;
8539 fail:
8540 {
8541 if (temp3)
8542 delete arg3;
8543 }
8544 return NULL;
8545 }
8546
8547
8548 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8549 PyObject *resultobj = NULL;
8550 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8551 wxString *arg2 = 0 ;
8552 int arg3 = (int) 0 ;
8553 wxString result;
8554 bool temp2 = false ;
8555 PyObject * obj0 = 0 ;
8556 PyObject * obj1 = 0 ;
8557 PyObject * obj2 = 0 ;
8558 char *kwnames[] = {
8559 (char *) "self",(char *) "spec",(char *) "flags", NULL
8560 };
8561
8562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8564 if (SWIG_arg_fail(1)) SWIG_fail;
8565 {
8566 arg2 = wxString_in_helper(obj1);
8567 if (arg2 == NULL) SWIG_fail;
8568 temp2 = true;
8569 }
8570 if (obj2) {
8571 {
8572 arg3 = static_cast<int >(SWIG_As_int(obj2));
8573 if (SWIG_arg_fail(3)) SWIG_fail;
8574 }
8575 }
8576 {
8577 PyThreadState* __tstate = wxPyBeginAllowThreads();
8578 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8579
8580 wxPyEndAllowThreads(__tstate);
8581 if (PyErr_Occurred()) SWIG_fail;
8582 }
8583 {
8584 #if wxUSE_UNICODE
8585 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8586 #else
8587 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8588 #endif
8589 }
8590 {
8591 if (temp2)
8592 delete arg2;
8593 }
8594 return resultobj;
8595 fail:
8596 {
8597 if (temp2)
8598 delete arg2;
8599 }
8600 return NULL;
8601 }
8602
8603
8604 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8605 PyObject *resultobj = NULL;
8606 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8607 wxString result;
8608 PyObject * obj0 = 0 ;
8609 char *kwnames[] = {
8610 (char *) "self", NULL
8611 };
8612
8613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8615 if (SWIG_arg_fail(1)) SWIG_fail;
8616 {
8617 PyThreadState* __tstate = wxPyBeginAllowThreads();
8618 result = (arg1)->FindNext();
8619
8620 wxPyEndAllowThreads(__tstate);
8621 if (PyErr_Occurred()) SWIG_fail;
8622 }
8623 {
8624 #if wxUSE_UNICODE
8625 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8626 #else
8627 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8628 #endif
8629 }
8630 return resultobj;
8631 fail:
8632 return NULL;
8633 }
8634
8635
8636 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8637 PyObject *resultobj = NULL;
8638 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8639 wxString *arg2 = 0 ;
8640 wxString result;
8641 bool temp2 = false ;
8642 PyObject * obj0 = 0 ;
8643 PyObject * obj1 = 0 ;
8644 char *kwnames[] = {
8645 (char *) "self",(char *) "location", NULL
8646 };
8647
8648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8650 if (SWIG_arg_fail(1)) SWIG_fail;
8651 {
8652 arg2 = wxString_in_helper(obj1);
8653 if (arg2 == NULL) SWIG_fail;
8654 temp2 = true;
8655 }
8656 {
8657 PyThreadState* __tstate = wxPyBeginAllowThreads();
8658 result = (arg1)->GetProtocol((wxString const &)*arg2);
8659
8660 wxPyEndAllowThreads(__tstate);
8661 if (PyErr_Occurred()) SWIG_fail;
8662 }
8663 {
8664 #if wxUSE_UNICODE
8665 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8666 #else
8667 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8668 #endif
8669 }
8670 {
8671 if (temp2)
8672 delete arg2;
8673 }
8674 return resultobj;
8675 fail:
8676 {
8677 if (temp2)
8678 delete arg2;
8679 }
8680 return NULL;
8681 }
8682
8683
8684 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8685 PyObject *resultobj = NULL;
8686 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8687 wxString *arg2 = 0 ;
8688 wxString result;
8689 bool temp2 = false ;
8690 PyObject * obj0 = 0 ;
8691 PyObject * obj1 = 0 ;
8692 char *kwnames[] = {
8693 (char *) "self",(char *) "location", NULL
8694 };
8695
8696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8698 if (SWIG_arg_fail(1)) SWIG_fail;
8699 {
8700 arg2 = wxString_in_helper(obj1);
8701 if (arg2 == NULL) SWIG_fail;
8702 temp2 = true;
8703 }
8704 {
8705 PyThreadState* __tstate = wxPyBeginAllowThreads();
8706 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8707
8708 wxPyEndAllowThreads(__tstate);
8709 if (PyErr_Occurred()) SWIG_fail;
8710 }
8711 {
8712 #if wxUSE_UNICODE
8713 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8714 #else
8715 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8716 #endif
8717 }
8718 {
8719 if (temp2)
8720 delete arg2;
8721 }
8722 return resultobj;
8723 fail:
8724 {
8725 if (temp2)
8726 delete arg2;
8727 }
8728 return NULL;
8729 }
8730
8731
8732 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8733 PyObject *resultobj = NULL;
8734 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8735 wxString *arg2 = 0 ;
8736 wxString result;
8737 bool temp2 = false ;
8738 PyObject * obj0 = 0 ;
8739 PyObject * obj1 = 0 ;
8740 char *kwnames[] = {
8741 (char *) "self",(char *) "location", NULL
8742 };
8743
8744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8746 if (SWIG_arg_fail(1)) SWIG_fail;
8747 {
8748 arg2 = wxString_in_helper(obj1);
8749 if (arg2 == NULL) SWIG_fail;
8750 temp2 = true;
8751 }
8752 {
8753 PyThreadState* __tstate = wxPyBeginAllowThreads();
8754 result = (arg1)->GetAnchor((wxString const &)*arg2);
8755
8756 wxPyEndAllowThreads(__tstate);
8757 if (PyErr_Occurred()) SWIG_fail;
8758 }
8759 {
8760 #if wxUSE_UNICODE
8761 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8762 #else
8763 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8764 #endif
8765 }
8766 {
8767 if (temp2)
8768 delete arg2;
8769 }
8770 return resultobj;
8771 fail:
8772 {
8773 if (temp2)
8774 delete arg2;
8775 }
8776 return NULL;
8777 }
8778
8779
8780 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8781 PyObject *resultobj = NULL;
8782 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8783 wxString *arg2 = 0 ;
8784 wxString result;
8785 bool temp2 = false ;
8786 PyObject * obj0 = 0 ;
8787 PyObject * obj1 = 0 ;
8788 char *kwnames[] = {
8789 (char *) "self",(char *) "location", NULL
8790 };
8791
8792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8794 if (SWIG_arg_fail(1)) SWIG_fail;
8795 {
8796 arg2 = wxString_in_helper(obj1);
8797 if (arg2 == NULL) SWIG_fail;
8798 temp2 = true;
8799 }
8800 {
8801 PyThreadState* __tstate = wxPyBeginAllowThreads();
8802 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8803
8804 wxPyEndAllowThreads(__tstate);
8805 if (PyErr_Occurred()) SWIG_fail;
8806 }
8807 {
8808 #if wxUSE_UNICODE
8809 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8810 #else
8811 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8812 #endif
8813 }
8814 {
8815 if (temp2)
8816 delete arg2;
8817 }
8818 return resultobj;
8819 fail:
8820 {
8821 if (temp2)
8822 delete arg2;
8823 }
8824 return NULL;
8825 }
8826
8827
8828 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8829 PyObject *resultobj = NULL;
8830 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8831 wxString *arg2 = 0 ;
8832 wxString result;
8833 bool temp2 = false ;
8834 PyObject * obj0 = 0 ;
8835 PyObject * obj1 = 0 ;
8836 char *kwnames[] = {
8837 (char *) "self",(char *) "location", NULL
8838 };
8839
8840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8842 if (SWIG_arg_fail(1)) SWIG_fail;
8843 {
8844 arg2 = wxString_in_helper(obj1);
8845 if (arg2 == NULL) SWIG_fail;
8846 temp2 = true;
8847 }
8848 {
8849 PyThreadState* __tstate = wxPyBeginAllowThreads();
8850 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8851
8852 wxPyEndAllowThreads(__tstate);
8853 if (PyErr_Occurred()) SWIG_fail;
8854 }
8855 {
8856 #if wxUSE_UNICODE
8857 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8858 #else
8859 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8860 #endif
8861 }
8862 {
8863 if (temp2)
8864 delete arg2;
8865 }
8866 return resultobj;
8867 fail:
8868 {
8869 if (temp2)
8870 delete arg2;
8871 }
8872 return NULL;
8873 }
8874
8875
8876 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8877 PyObject *obj;
8878 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8879 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8880 Py_INCREF(obj);
8881 return Py_BuildValue((char *)"");
8882 }
8883 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8884 PyObject *resultobj = NULL;
8885 wxFileSystem *result;
8886 char *kwnames[] = {
8887 NULL
8888 };
8889
8890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8891 {
8892 PyThreadState* __tstate = wxPyBeginAllowThreads();
8893 result = (wxFileSystem *)new wxFileSystem();
8894
8895 wxPyEndAllowThreads(__tstate);
8896 if (PyErr_Occurred()) SWIG_fail;
8897 }
8898 {
8899 resultobj = wxPyMake_wxObject(result, (bool)1);
8900 }
8901 return resultobj;
8902 fail:
8903 return NULL;
8904 }
8905
8906
8907 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8908 PyObject *resultobj = NULL;
8909 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8910 PyObject * obj0 = 0 ;
8911 char *kwnames[] = {
8912 (char *) "self", NULL
8913 };
8914
8915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8917 if (SWIG_arg_fail(1)) SWIG_fail;
8918 {
8919 PyThreadState* __tstate = wxPyBeginAllowThreads();
8920 delete arg1;
8921
8922 wxPyEndAllowThreads(__tstate);
8923 if (PyErr_Occurred()) SWIG_fail;
8924 }
8925 Py_INCREF(Py_None); resultobj = Py_None;
8926 return resultobj;
8927 fail:
8928 return NULL;
8929 }
8930
8931
8932 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8933 PyObject *resultobj = NULL;
8934 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8935 wxString *arg2 = 0 ;
8936 bool arg3 = (bool) false ;
8937 bool temp2 = false ;
8938 PyObject * obj0 = 0 ;
8939 PyObject * obj1 = 0 ;
8940 PyObject * obj2 = 0 ;
8941 char *kwnames[] = {
8942 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8943 };
8944
8945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8947 if (SWIG_arg_fail(1)) SWIG_fail;
8948 {
8949 arg2 = wxString_in_helper(obj1);
8950 if (arg2 == NULL) SWIG_fail;
8951 temp2 = true;
8952 }
8953 if (obj2) {
8954 {
8955 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
8956 if (SWIG_arg_fail(3)) SWIG_fail;
8957 }
8958 }
8959 {
8960 PyThreadState* __tstate = wxPyBeginAllowThreads();
8961 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8962
8963 wxPyEndAllowThreads(__tstate);
8964 if (PyErr_Occurred()) SWIG_fail;
8965 }
8966 Py_INCREF(Py_None); resultobj = Py_None;
8967 {
8968 if (temp2)
8969 delete arg2;
8970 }
8971 return resultobj;
8972 fail:
8973 {
8974 if (temp2)
8975 delete arg2;
8976 }
8977 return NULL;
8978 }
8979
8980
8981 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8982 PyObject *resultobj = NULL;
8983 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8984 wxString result;
8985 PyObject * obj0 = 0 ;
8986 char *kwnames[] = {
8987 (char *) "self", NULL
8988 };
8989
8990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8992 if (SWIG_arg_fail(1)) SWIG_fail;
8993 {
8994 PyThreadState* __tstate = wxPyBeginAllowThreads();
8995 result = (arg1)->GetPath();
8996
8997 wxPyEndAllowThreads(__tstate);
8998 if (PyErr_Occurred()) SWIG_fail;
8999 }
9000 {
9001 #if wxUSE_UNICODE
9002 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9003 #else
9004 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9005 #endif
9006 }
9007 return resultobj;
9008 fail:
9009 return NULL;
9010 }
9011
9012
9013 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9014 PyObject *resultobj = NULL;
9015 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9016 wxString *arg2 = 0 ;
9017 wxFSFile *result;
9018 bool temp2 = false ;
9019 PyObject * obj0 = 0 ;
9020 PyObject * obj1 = 0 ;
9021 char *kwnames[] = {
9022 (char *) "self",(char *) "location", NULL
9023 };
9024
9025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
9026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9027 if (SWIG_arg_fail(1)) SWIG_fail;
9028 {
9029 arg2 = wxString_in_helper(obj1);
9030 if (arg2 == NULL) SWIG_fail;
9031 temp2 = true;
9032 }
9033 {
9034 PyThreadState* __tstate = wxPyBeginAllowThreads();
9035 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
9036
9037 wxPyEndAllowThreads(__tstate);
9038 if (PyErr_Occurred()) SWIG_fail;
9039 }
9040 {
9041 resultobj = wxPyMake_wxObject(result, (bool)1);
9042 }
9043 {
9044 if (temp2)
9045 delete arg2;
9046 }
9047 return resultobj;
9048 fail:
9049 {
9050 if (temp2)
9051 delete arg2;
9052 }
9053 return NULL;
9054 }
9055
9056
9057 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9058 PyObject *resultobj = NULL;
9059 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9060 wxString *arg2 = 0 ;
9061 int arg3 = (int) 0 ;
9062 wxString result;
9063 bool temp2 = false ;
9064 PyObject * obj0 = 0 ;
9065 PyObject * obj1 = 0 ;
9066 PyObject * obj2 = 0 ;
9067 char *kwnames[] = {
9068 (char *) "self",(char *) "spec",(char *) "flags", NULL
9069 };
9070
9071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9073 if (SWIG_arg_fail(1)) SWIG_fail;
9074 {
9075 arg2 = wxString_in_helper(obj1);
9076 if (arg2 == NULL) SWIG_fail;
9077 temp2 = true;
9078 }
9079 if (obj2) {
9080 {
9081 arg3 = static_cast<int >(SWIG_As_int(obj2));
9082 if (SWIG_arg_fail(3)) SWIG_fail;
9083 }
9084 }
9085 {
9086 PyThreadState* __tstate = wxPyBeginAllowThreads();
9087 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9088
9089 wxPyEndAllowThreads(__tstate);
9090 if (PyErr_Occurred()) SWIG_fail;
9091 }
9092 {
9093 #if wxUSE_UNICODE
9094 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9095 #else
9096 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9097 #endif
9098 }
9099 {
9100 if (temp2)
9101 delete arg2;
9102 }
9103 return resultobj;
9104 fail:
9105 {
9106 if (temp2)
9107 delete arg2;
9108 }
9109 return NULL;
9110 }
9111
9112
9113 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9114 PyObject *resultobj = NULL;
9115 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
9116 wxString result;
9117 PyObject * obj0 = 0 ;
9118 char *kwnames[] = {
9119 (char *) "self", NULL
9120 };
9121
9122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
9123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9124 if (SWIG_arg_fail(1)) SWIG_fail;
9125 {
9126 PyThreadState* __tstate = wxPyBeginAllowThreads();
9127 result = (arg1)->FindNext();
9128
9129 wxPyEndAllowThreads(__tstate);
9130 if (PyErr_Occurred()) SWIG_fail;
9131 }
9132 {
9133 #if wxUSE_UNICODE
9134 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9135 #else
9136 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9137 #endif
9138 }
9139 return resultobj;
9140 fail:
9141 return NULL;
9142 }
9143
9144
9145 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9146 PyObject *resultobj = NULL;
9147 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9148 PyObject * obj0 = 0 ;
9149 char *kwnames[] = {
9150 (char *) "handler", NULL
9151 };
9152
9153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9155 if (SWIG_arg_fail(1)) SWIG_fail;
9156 {
9157 PyThreadState* __tstate = wxPyBeginAllowThreads();
9158 wxFileSystem::AddHandler(arg1);
9159
9160 wxPyEndAllowThreads(__tstate);
9161 if (PyErr_Occurred()) SWIG_fail;
9162 }
9163 Py_INCREF(Py_None); resultobj = Py_None;
9164 return resultobj;
9165 fail:
9166 return NULL;
9167 }
9168
9169
9170 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9171 PyObject *resultobj = NULL;
9172 char *kwnames[] = {
9173 NULL
9174 };
9175
9176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9177 {
9178 PyThreadState* __tstate = wxPyBeginAllowThreads();
9179 wxFileSystem::CleanUpHandlers();
9180
9181 wxPyEndAllowThreads(__tstate);
9182 if (PyErr_Occurred()) SWIG_fail;
9183 }
9184 Py_INCREF(Py_None); resultobj = Py_None;
9185 return resultobj;
9186 fail:
9187 return NULL;
9188 }
9189
9190
9191 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9192 PyObject *resultobj = NULL;
9193 wxString *arg1 = 0 ;
9194 wxString result;
9195 bool temp1 = false ;
9196 PyObject * obj0 = 0 ;
9197 char *kwnames[] = {
9198 (char *) "filename", NULL
9199 };
9200
9201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9202 {
9203 arg1 = wxString_in_helper(obj0);
9204 if (arg1 == NULL) SWIG_fail;
9205 temp1 = true;
9206 }
9207 {
9208 PyThreadState* __tstate = wxPyBeginAllowThreads();
9209 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9210
9211 wxPyEndAllowThreads(__tstate);
9212 if (PyErr_Occurred()) SWIG_fail;
9213 }
9214 {
9215 #if wxUSE_UNICODE
9216 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9217 #else
9218 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9219 #endif
9220 }
9221 {
9222 if (temp1)
9223 delete arg1;
9224 }
9225 return resultobj;
9226 fail:
9227 {
9228 if (temp1)
9229 delete arg1;
9230 }
9231 return NULL;
9232 }
9233
9234
9235 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9236 PyObject *resultobj = NULL;
9237 wxString *arg1 = 0 ;
9238 wxString result;
9239 bool temp1 = false ;
9240 PyObject * obj0 = 0 ;
9241 char *kwnames[] = {
9242 (char *) "url", NULL
9243 };
9244
9245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9246 {
9247 arg1 = wxString_in_helper(obj0);
9248 if (arg1 == NULL) SWIG_fail;
9249 temp1 = true;
9250 }
9251 {
9252 PyThreadState* __tstate = wxPyBeginAllowThreads();
9253 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
9254
9255 wxPyEndAllowThreads(__tstate);
9256 if (PyErr_Occurred()) SWIG_fail;
9257 }
9258 {
9259 #if wxUSE_UNICODE
9260 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9261 #else
9262 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9263 #endif
9264 }
9265 {
9266 if (temp1)
9267 delete arg1;
9268 }
9269 return resultobj;
9270 fail:
9271 {
9272 if (temp1)
9273 delete arg1;
9274 }
9275 return NULL;
9276 }
9277
9278
9279 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9280 PyObject *obj;
9281 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9282 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9283 Py_INCREF(obj);
9284 return Py_BuildValue((char *)"");
9285 }
9286 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9287 PyObject *resultobj = NULL;
9288 wxInternetFSHandler *result;
9289 char *kwnames[] = {
9290 NULL
9291 };
9292
9293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9294 {
9295 PyThreadState* __tstate = wxPyBeginAllowThreads();
9296 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9297
9298 wxPyEndAllowThreads(__tstate);
9299 if (PyErr_Occurred()) SWIG_fail;
9300 }
9301 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9302 return resultobj;
9303 fail:
9304 return NULL;
9305 }
9306
9307
9308 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9309 PyObject *resultobj = NULL;
9310 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9311 wxString *arg2 = 0 ;
9312 bool result;
9313 bool temp2 = false ;
9314 PyObject * obj0 = 0 ;
9315 PyObject * obj1 = 0 ;
9316 char *kwnames[] = {
9317 (char *) "self",(char *) "location", NULL
9318 };
9319
9320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9322 if (SWIG_arg_fail(1)) SWIG_fail;
9323 {
9324 arg2 = wxString_in_helper(obj1);
9325 if (arg2 == NULL) SWIG_fail;
9326 temp2 = true;
9327 }
9328 {
9329 PyThreadState* __tstate = wxPyBeginAllowThreads();
9330 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9331
9332 wxPyEndAllowThreads(__tstate);
9333 if (PyErr_Occurred()) SWIG_fail;
9334 }
9335 {
9336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9337 }
9338 {
9339 if (temp2)
9340 delete arg2;
9341 }
9342 return resultobj;
9343 fail:
9344 {
9345 if (temp2)
9346 delete arg2;
9347 }
9348 return NULL;
9349 }
9350
9351
9352 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9353 PyObject *resultobj = NULL;
9354 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9355 wxFileSystem *arg2 = 0 ;
9356 wxString *arg3 = 0 ;
9357 wxFSFile *result;
9358 bool temp3 = false ;
9359 PyObject * obj0 = 0 ;
9360 PyObject * obj1 = 0 ;
9361 PyObject * obj2 = 0 ;
9362 char *kwnames[] = {
9363 (char *) "self",(char *) "fs",(char *) "location", NULL
9364 };
9365
9366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9368 if (SWIG_arg_fail(1)) SWIG_fail;
9369 {
9370 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9371 if (SWIG_arg_fail(2)) SWIG_fail;
9372 if (arg2 == NULL) {
9373 SWIG_null_ref("wxFileSystem");
9374 }
9375 if (SWIG_arg_fail(2)) SWIG_fail;
9376 }
9377 {
9378 arg3 = wxString_in_helper(obj2);
9379 if (arg3 == NULL) SWIG_fail;
9380 temp3 = true;
9381 }
9382 {
9383 PyThreadState* __tstate = wxPyBeginAllowThreads();
9384 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9385
9386 wxPyEndAllowThreads(__tstate);
9387 if (PyErr_Occurred()) SWIG_fail;
9388 }
9389 {
9390 resultobj = wxPyMake_wxObject(result, (bool)1);
9391 }
9392 {
9393 if (temp3)
9394 delete arg3;
9395 }
9396 return resultobj;
9397 fail:
9398 {
9399 if (temp3)
9400 delete arg3;
9401 }
9402 return NULL;
9403 }
9404
9405
9406 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9407 PyObject *obj;
9408 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9409 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9410 Py_INCREF(obj);
9411 return Py_BuildValue((char *)"");
9412 }
9413 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9414 PyObject *resultobj = NULL;
9415 wxZipFSHandler *result;
9416 char *kwnames[] = {
9417 NULL
9418 };
9419
9420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9421 {
9422 PyThreadState* __tstate = wxPyBeginAllowThreads();
9423 result = (wxZipFSHandler *)new wxZipFSHandler();
9424
9425 wxPyEndAllowThreads(__tstate);
9426 if (PyErr_Occurred()) SWIG_fail;
9427 }
9428 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9429 return resultobj;
9430 fail:
9431 return NULL;
9432 }
9433
9434
9435 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9436 PyObject *resultobj = NULL;
9437 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9438 wxString *arg2 = 0 ;
9439 bool result;
9440 bool temp2 = false ;
9441 PyObject * obj0 = 0 ;
9442 PyObject * obj1 = 0 ;
9443 char *kwnames[] = {
9444 (char *) "self",(char *) "location", NULL
9445 };
9446
9447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9449 if (SWIG_arg_fail(1)) SWIG_fail;
9450 {
9451 arg2 = wxString_in_helper(obj1);
9452 if (arg2 == NULL) SWIG_fail;
9453 temp2 = true;
9454 }
9455 {
9456 PyThreadState* __tstate = wxPyBeginAllowThreads();
9457 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9458
9459 wxPyEndAllowThreads(__tstate);
9460 if (PyErr_Occurred()) SWIG_fail;
9461 }
9462 {
9463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9464 }
9465 {
9466 if (temp2)
9467 delete arg2;
9468 }
9469 return resultobj;
9470 fail:
9471 {
9472 if (temp2)
9473 delete arg2;
9474 }
9475 return NULL;
9476 }
9477
9478
9479 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9480 PyObject *resultobj = NULL;
9481 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9482 wxFileSystem *arg2 = 0 ;
9483 wxString *arg3 = 0 ;
9484 wxFSFile *result;
9485 bool temp3 = false ;
9486 PyObject * obj0 = 0 ;
9487 PyObject * obj1 = 0 ;
9488 PyObject * obj2 = 0 ;
9489 char *kwnames[] = {
9490 (char *) "self",(char *) "fs",(char *) "location", NULL
9491 };
9492
9493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9495 if (SWIG_arg_fail(1)) SWIG_fail;
9496 {
9497 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9498 if (SWIG_arg_fail(2)) SWIG_fail;
9499 if (arg2 == NULL) {
9500 SWIG_null_ref("wxFileSystem");
9501 }
9502 if (SWIG_arg_fail(2)) SWIG_fail;
9503 }
9504 {
9505 arg3 = wxString_in_helper(obj2);
9506 if (arg3 == NULL) SWIG_fail;
9507 temp3 = true;
9508 }
9509 {
9510 PyThreadState* __tstate = wxPyBeginAllowThreads();
9511 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9512
9513 wxPyEndAllowThreads(__tstate);
9514 if (PyErr_Occurred()) SWIG_fail;
9515 }
9516 {
9517 resultobj = wxPyMake_wxObject(result, (bool)1);
9518 }
9519 {
9520 if (temp3)
9521 delete arg3;
9522 }
9523 return resultobj;
9524 fail:
9525 {
9526 if (temp3)
9527 delete arg3;
9528 }
9529 return NULL;
9530 }
9531
9532
9533 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9534 PyObject *resultobj = NULL;
9535 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9536 wxString *arg2 = 0 ;
9537 int arg3 = (int) 0 ;
9538 wxString result;
9539 bool temp2 = false ;
9540 PyObject * obj0 = 0 ;
9541 PyObject * obj1 = 0 ;
9542 PyObject * obj2 = 0 ;
9543 char *kwnames[] = {
9544 (char *) "self",(char *) "spec",(char *) "flags", NULL
9545 };
9546
9547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9549 if (SWIG_arg_fail(1)) SWIG_fail;
9550 {
9551 arg2 = wxString_in_helper(obj1);
9552 if (arg2 == NULL) SWIG_fail;
9553 temp2 = true;
9554 }
9555 if (obj2) {
9556 {
9557 arg3 = static_cast<int >(SWIG_As_int(obj2));
9558 if (SWIG_arg_fail(3)) SWIG_fail;
9559 }
9560 }
9561 {
9562 PyThreadState* __tstate = wxPyBeginAllowThreads();
9563 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9564
9565 wxPyEndAllowThreads(__tstate);
9566 if (PyErr_Occurred()) SWIG_fail;
9567 }
9568 {
9569 #if wxUSE_UNICODE
9570 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9571 #else
9572 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9573 #endif
9574 }
9575 {
9576 if (temp2)
9577 delete arg2;
9578 }
9579 return resultobj;
9580 fail:
9581 {
9582 if (temp2)
9583 delete arg2;
9584 }
9585 return NULL;
9586 }
9587
9588
9589 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9590 PyObject *resultobj = NULL;
9591 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9592 wxString result;
9593 PyObject * obj0 = 0 ;
9594 char *kwnames[] = {
9595 (char *) "self", NULL
9596 };
9597
9598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9600 if (SWIG_arg_fail(1)) SWIG_fail;
9601 {
9602 PyThreadState* __tstate = wxPyBeginAllowThreads();
9603 result = (arg1)->FindNext();
9604
9605 wxPyEndAllowThreads(__tstate);
9606 if (PyErr_Occurred()) SWIG_fail;
9607 }
9608 {
9609 #if wxUSE_UNICODE
9610 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9611 #else
9612 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9613 #endif
9614 }
9615 return resultobj;
9616 fail:
9617 return NULL;
9618 }
9619
9620
9621 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9622 PyObject *obj;
9623 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9624 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9625 Py_INCREF(obj);
9626 return Py_BuildValue((char *)"");
9627 }
9628 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9629 PyObject *resultobj = NULL;
9630 wxString *arg1 = 0 ;
9631 wxImage *arg2 = 0 ;
9632 long arg3 ;
9633 bool temp1 = false ;
9634 PyObject * obj0 = 0 ;
9635 PyObject * obj1 = 0 ;
9636 PyObject * obj2 = 0 ;
9637 char *kwnames[] = {
9638 (char *) "filename",(char *) "image",(char *) "type", NULL
9639 };
9640
9641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9642 {
9643 arg1 = wxString_in_helper(obj0);
9644 if (arg1 == NULL) SWIG_fail;
9645 temp1 = true;
9646 }
9647 {
9648 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9649 if (SWIG_arg_fail(2)) SWIG_fail;
9650 if (arg2 == NULL) {
9651 SWIG_null_ref("wxImage");
9652 }
9653 if (SWIG_arg_fail(2)) SWIG_fail;
9654 }
9655 {
9656 arg3 = static_cast<long >(SWIG_As_long(obj2));
9657 if (SWIG_arg_fail(3)) SWIG_fail;
9658 }
9659 {
9660 PyThreadState* __tstate = wxPyBeginAllowThreads();
9661 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9662
9663 wxPyEndAllowThreads(__tstate);
9664 if (PyErr_Occurred()) SWIG_fail;
9665 }
9666 Py_INCREF(Py_None); resultobj = Py_None;
9667 {
9668 if (temp1)
9669 delete arg1;
9670 }
9671 return resultobj;
9672 fail:
9673 {
9674 if (temp1)
9675 delete arg1;
9676 }
9677 return NULL;
9678 }
9679
9680
9681 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9682 PyObject *resultobj = NULL;
9683 wxString *arg1 = 0 ;
9684 wxBitmap *arg2 = 0 ;
9685 long arg3 ;
9686 bool temp1 = false ;
9687 PyObject * obj0 = 0 ;
9688 PyObject * obj1 = 0 ;
9689 PyObject * obj2 = 0 ;
9690 char *kwnames[] = {
9691 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9692 };
9693
9694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9695 {
9696 arg1 = wxString_in_helper(obj0);
9697 if (arg1 == NULL) SWIG_fail;
9698 temp1 = true;
9699 }
9700 {
9701 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9702 if (SWIG_arg_fail(2)) SWIG_fail;
9703 if (arg2 == NULL) {
9704 SWIG_null_ref("wxBitmap");
9705 }
9706 if (SWIG_arg_fail(2)) SWIG_fail;
9707 }
9708 {
9709 arg3 = static_cast<long >(SWIG_As_long(obj2));
9710 if (SWIG_arg_fail(3)) SWIG_fail;
9711 }
9712 {
9713 PyThreadState* __tstate = wxPyBeginAllowThreads();
9714 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9715
9716 wxPyEndAllowThreads(__tstate);
9717 if (PyErr_Occurred()) SWIG_fail;
9718 }
9719 Py_INCREF(Py_None); resultobj = Py_None;
9720 {
9721 if (temp1)
9722 delete arg1;
9723 }
9724 return resultobj;
9725 fail:
9726 {
9727 if (temp1)
9728 delete arg1;
9729 }
9730 return NULL;
9731 }
9732
9733
9734 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9735 PyObject *resultobj = NULL;
9736 wxString *arg1 = 0 ;
9737 PyObject *arg2 = (PyObject *) 0 ;
9738 bool temp1 = false ;
9739 PyObject * obj0 = 0 ;
9740 PyObject * obj1 = 0 ;
9741 char *kwnames[] = {
9742 (char *) "filename",(char *) "data", NULL
9743 };
9744
9745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9746 {
9747 arg1 = wxString_in_helper(obj0);
9748 if (arg1 == NULL) SWIG_fail;
9749 temp1 = true;
9750 }
9751 arg2 = obj1;
9752 {
9753 PyThreadState* __tstate = wxPyBeginAllowThreads();
9754 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9755
9756 wxPyEndAllowThreads(__tstate);
9757 if (PyErr_Occurred()) SWIG_fail;
9758 }
9759 Py_INCREF(Py_None); resultobj = Py_None;
9760 {
9761 if (temp1)
9762 delete arg1;
9763 }
9764 return resultobj;
9765 fail:
9766 {
9767 if (temp1)
9768 delete arg1;
9769 }
9770 return NULL;
9771 }
9772
9773
9774 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9775 PyObject *resultobj = NULL;
9776 wxMemoryFSHandler *result;
9777 char *kwnames[] = {
9778 NULL
9779 };
9780
9781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9782 {
9783 PyThreadState* __tstate = wxPyBeginAllowThreads();
9784 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9785
9786 wxPyEndAllowThreads(__tstate);
9787 if (PyErr_Occurred()) SWIG_fail;
9788 }
9789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9790 return resultobj;
9791 fail:
9792 return NULL;
9793 }
9794
9795
9796 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9797 PyObject *resultobj = NULL;
9798 wxString *arg1 = 0 ;
9799 bool temp1 = false ;
9800 PyObject * obj0 = 0 ;
9801 char *kwnames[] = {
9802 (char *) "filename", NULL
9803 };
9804
9805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9806 {
9807 arg1 = wxString_in_helper(obj0);
9808 if (arg1 == NULL) SWIG_fail;
9809 temp1 = true;
9810 }
9811 {
9812 PyThreadState* __tstate = wxPyBeginAllowThreads();
9813 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9814
9815 wxPyEndAllowThreads(__tstate);
9816 if (PyErr_Occurred()) SWIG_fail;
9817 }
9818 Py_INCREF(Py_None); resultobj = Py_None;
9819 {
9820 if (temp1)
9821 delete arg1;
9822 }
9823 return resultobj;
9824 fail:
9825 {
9826 if (temp1)
9827 delete arg1;
9828 }
9829 return NULL;
9830 }
9831
9832
9833 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9834 PyObject *resultobj = NULL;
9835 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9836 wxString *arg2 = 0 ;
9837 bool result;
9838 bool temp2 = false ;
9839 PyObject * obj0 = 0 ;
9840 PyObject * obj1 = 0 ;
9841 char *kwnames[] = {
9842 (char *) "self",(char *) "location", NULL
9843 };
9844
9845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9847 if (SWIG_arg_fail(1)) SWIG_fail;
9848 {
9849 arg2 = wxString_in_helper(obj1);
9850 if (arg2 == NULL) SWIG_fail;
9851 temp2 = true;
9852 }
9853 {
9854 PyThreadState* __tstate = wxPyBeginAllowThreads();
9855 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9856
9857 wxPyEndAllowThreads(__tstate);
9858 if (PyErr_Occurred()) SWIG_fail;
9859 }
9860 {
9861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9862 }
9863 {
9864 if (temp2)
9865 delete arg2;
9866 }
9867 return resultobj;
9868 fail:
9869 {
9870 if (temp2)
9871 delete arg2;
9872 }
9873 return NULL;
9874 }
9875
9876
9877 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9878 PyObject *resultobj = NULL;
9879 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9880 wxFileSystem *arg2 = 0 ;
9881 wxString *arg3 = 0 ;
9882 wxFSFile *result;
9883 bool temp3 = false ;
9884 PyObject * obj0 = 0 ;
9885 PyObject * obj1 = 0 ;
9886 PyObject * obj2 = 0 ;
9887 char *kwnames[] = {
9888 (char *) "self",(char *) "fs",(char *) "location", NULL
9889 };
9890
9891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9893 if (SWIG_arg_fail(1)) SWIG_fail;
9894 {
9895 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9896 if (SWIG_arg_fail(2)) SWIG_fail;
9897 if (arg2 == NULL) {
9898 SWIG_null_ref("wxFileSystem");
9899 }
9900 if (SWIG_arg_fail(2)) SWIG_fail;
9901 }
9902 {
9903 arg3 = wxString_in_helper(obj2);
9904 if (arg3 == NULL) SWIG_fail;
9905 temp3 = true;
9906 }
9907 {
9908 PyThreadState* __tstate = wxPyBeginAllowThreads();
9909 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9910
9911 wxPyEndAllowThreads(__tstate);
9912 if (PyErr_Occurred()) SWIG_fail;
9913 }
9914 {
9915 resultobj = wxPyMake_wxObject(result, (bool)1);
9916 }
9917 {
9918 if (temp3)
9919 delete arg3;
9920 }
9921 return resultobj;
9922 fail:
9923 {
9924 if (temp3)
9925 delete arg3;
9926 }
9927 return NULL;
9928 }
9929
9930
9931 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9932 PyObject *resultobj = NULL;
9933 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9934 wxString *arg2 = 0 ;
9935 int arg3 = (int) 0 ;
9936 wxString result;
9937 bool temp2 = false ;
9938 PyObject * obj0 = 0 ;
9939 PyObject * obj1 = 0 ;
9940 PyObject * obj2 = 0 ;
9941 char *kwnames[] = {
9942 (char *) "self",(char *) "spec",(char *) "flags", NULL
9943 };
9944
9945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9947 if (SWIG_arg_fail(1)) SWIG_fail;
9948 {
9949 arg2 = wxString_in_helper(obj1);
9950 if (arg2 == NULL) SWIG_fail;
9951 temp2 = true;
9952 }
9953 if (obj2) {
9954 {
9955 arg3 = static_cast<int >(SWIG_As_int(obj2));
9956 if (SWIG_arg_fail(3)) SWIG_fail;
9957 }
9958 }
9959 {
9960 PyThreadState* __tstate = wxPyBeginAllowThreads();
9961 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9962
9963 wxPyEndAllowThreads(__tstate);
9964 if (PyErr_Occurred()) SWIG_fail;
9965 }
9966 {
9967 #if wxUSE_UNICODE
9968 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9969 #else
9970 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9971 #endif
9972 }
9973 {
9974 if (temp2)
9975 delete arg2;
9976 }
9977 return resultobj;
9978 fail:
9979 {
9980 if (temp2)
9981 delete arg2;
9982 }
9983 return NULL;
9984 }
9985
9986
9987 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9988 PyObject *resultobj = NULL;
9989 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9990 wxString result;
9991 PyObject * obj0 = 0 ;
9992 char *kwnames[] = {
9993 (char *) "self", NULL
9994 };
9995
9996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9998 if (SWIG_arg_fail(1)) SWIG_fail;
9999 {
10000 PyThreadState* __tstate = wxPyBeginAllowThreads();
10001 result = (arg1)->FindNext();
10002
10003 wxPyEndAllowThreads(__tstate);
10004 if (PyErr_Occurred()) SWIG_fail;
10005 }
10006 {
10007 #if wxUSE_UNICODE
10008 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10009 #else
10010 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10011 #endif
10012 }
10013 return resultobj;
10014 fail:
10015 return NULL;
10016 }
10017
10018
10019 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
10020 PyObject *obj;
10021 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10022 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
10023 Py_INCREF(obj);
10024 return Py_BuildValue((char *)"");
10025 }
10026 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
10027 PyObject *resultobj = NULL;
10028 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10029 wxString result;
10030 PyObject * obj0 = 0 ;
10031 char *kwnames[] = {
10032 (char *) "self", NULL
10033 };
10034
10035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
10036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10037 if (SWIG_arg_fail(1)) SWIG_fail;
10038 {
10039 PyThreadState* __tstate = wxPyBeginAllowThreads();
10040 result = (arg1)->GetName();
10041
10042 wxPyEndAllowThreads(__tstate);
10043 if (PyErr_Occurred()) SWIG_fail;
10044 }
10045 {
10046 #if wxUSE_UNICODE
10047 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10048 #else
10049 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10050 #endif
10051 }
10052 return resultobj;
10053 fail:
10054 return NULL;
10055 }
10056
10057
10058 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10059 PyObject *resultobj = NULL;
10060 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10061 wxString result;
10062 PyObject * obj0 = 0 ;
10063 char *kwnames[] = {
10064 (char *) "self", NULL
10065 };
10066
10067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
10068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10069 if (SWIG_arg_fail(1)) SWIG_fail;
10070 {
10071 PyThreadState* __tstate = wxPyBeginAllowThreads();
10072 result = (arg1)->GetExtension();
10073
10074 wxPyEndAllowThreads(__tstate);
10075 if (PyErr_Occurred()) SWIG_fail;
10076 }
10077 {
10078 #if wxUSE_UNICODE
10079 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10080 #else
10081 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10082 #endif
10083 }
10084 return resultobj;
10085 fail:
10086 return NULL;
10087 }
10088
10089
10090 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
10091 PyObject *resultobj = NULL;
10092 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10093 long result;
10094 PyObject * obj0 = 0 ;
10095 char *kwnames[] = {
10096 (char *) "self", NULL
10097 };
10098
10099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
10100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10101 if (SWIG_arg_fail(1)) SWIG_fail;
10102 {
10103 PyThreadState* __tstate = wxPyBeginAllowThreads();
10104 result = (long)(arg1)->GetType();
10105
10106 wxPyEndAllowThreads(__tstate);
10107 if (PyErr_Occurred()) SWIG_fail;
10108 }
10109 {
10110 resultobj = SWIG_From_long(static_cast<long >(result));
10111 }
10112 return resultobj;
10113 fail:
10114 return NULL;
10115 }
10116
10117
10118 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10119 PyObject *resultobj = NULL;
10120 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10121 wxString result;
10122 PyObject * obj0 = 0 ;
10123 char *kwnames[] = {
10124 (char *) "self", NULL
10125 };
10126
10127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
10128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10129 if (SWIG_arg_fail(1)) SWIG_fail;
10130 {
10131 PyThreadState* __tstate = wxPyBeginAllowThreads();
10132 result = (arg1)->GetMimeType();
10133
10134 wxPyEndAllowThreads(__tstate);
10135 if (PyErr_Occurred()) SWIG_fail;
10136 }
10137 {
10138 #if wxUSE_UNICODE
10139 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10140 #else
10141 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10142 #endif
10143 }
10144 return resultobj;
10145 fail:
10146 return NULL;
10147 }
10148
10149
10150 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10151 PyObject *resultobj = NULL;
10152 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10153 wxString *arg2 = 0 ;
10154 bool result;
10155 bool temp2 = false ;
10156 PyObject * obj0 = 0 ;
10157 PyObject * obj1 = 0 ;
10158 char *kwnames[] = {
10159 (char *) "self",(char *) "name", NULL
10160 };
10161
10162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10164 if (SWIG_arg_fail(1)) SWIG_fail;
10165 {
10166 arg2 = wxString_in_helper(obj1);
10167 if (arg2 == NULL) SWIG_fail;
10168 temp2 = true;
10169 }
10170 {
10171 PyThreadState* __tstate = wxPyBeginAllowThreads();
10172 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10173
10174 wxPyEndAllowThreads(__tstate);
10175 if (PyErr_Occurred()) SWIG_fail;
10176 }
10177 {
10178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10179 }
10180 {
10181 if (temp2)
10182 delete arg2;
10183 }
10184 return resultobj;
10185 fail:
10186 {
10187 if (temp2)
10188 delete arg2;
10189 }
10190 return NULL;
10191 }
10192
10193
10194 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10195 PyObject *resultobj = NULL;
10196 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10197 wxString *arg2 = 0 ;
10198 bool temp2 = false ;
10199 PyObject * obj0 = 0 ;
10200 PyObject * obj1 = 0 ;
10201 char *kwnames[] = {
10202 (char *) "self",(char *) "name", NULL
10203 };
10204
10205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10207 if (SWIG_arg_fail(1)) SWIG_fail;
10208 {
10209 arg2 = wxString_in_helper(obj1);
10210 if (arg2 == NULL) SWIG_fail;
10211 temp2 = true;
10212 }
10213 {
10214 PyThreadState* __tstate = wxPyBeginAllowThreads();
10215 (arg1)->SetName((wxString const &)*arg2);
10216
10217 wxPyEndAllowThreads(__tstate);
10218 if (PyErr_Occurred()) SWIG_fail;
10219 }
10220 Py_INCREF(Py_None); resultobj = Py_None;
10221 {
10222 if (temp2)
10223 delete arg2;
10224 }
10225 return resultobj;
10226 fail:
10227 {
10228 if (temp2)
10229 delete arg2;
10230 }
10231 return NULL;
10232 }
10233
10234
10235 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10236 PyObject *resultobj = NULL;
10237 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10238 wxString *arg2 = 0 ;
10239 bool temp2 = false ;
10240 PyObject * obj0 = 0 ;
10241 PyObject * obj1 = 0 ;
10242 char *kwnames[] = {
10243 (char *) "self",(char *) "extension", NULL
10244 };
10245
10246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10248 if (SWIG_arg_fail(1)) SWIG_fail;
10249 {
10250 arg2 = wxString_in_helper(obj1);
10251 if (arg2 == NULL) SWIG_fail;
10252 temp2 = true;
10253 }
10254 {
10255 PyThreadState* __tstate = wxPyBeginAllowThreads();
10256 (arg1)->SetExtension((wxString const &)*arg2);
10257
10258 wxPyEndAllowThreads(__tstate);
10259 if (PyErr_Occurred()) SWIG_fail;
10260 }
10261 Py_INCREF(Py_None); resultobj = Py_None;
10262 {
10263 if (temp2)
10264 delete arg2;
10265 }
10266 return resultobj;
10267 fail:
10268 {
10269 if (temp2)
10270 delete arg2;
10271 }
10272 return NULL;
10273 }
10274
10275
10276 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10277 PyObject *resultobj = NULL;
10278 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10279 long arg2 ;
10280 PyObject * obj0 = 0 ;
10281 PyObject * obj1 = 0 ;
10282 char *kwnames[] = {
10283 (char *) "self",(char *) "type", NULL
10284 };
10285
10286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10288 if (SWIG_arg_fail(1)) SWIG_fail;
10289 {
10290 arg2 = static_cast<long >(SWIG_As_long(obj1));
10291 if (SWIG_arg_fail(2)) SWIG_fail;
10292 }
10293 {
10294 PyThreadState* __tstate = wxPyBeginAllowThreads();
10295 (arg1)->SetType(arg2);
10296
10297 wxPyEndAllowThreads(__tstate);
10298 if (PyErr_Occurred()) SWIG_fail;
10299 }
10300 Py_INCREF(Py_None); resultobj = Py_None;
10301 return resultobj;
10302 fail:
10303 return NULL;
10304 }
10305
10306
10307 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10308 PyObject *resultobj = NULL;
10309 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10310 wxString *arg2 = 0 ;
10311 bool temp2 = false ;
10312 PyObject * obj0 = 0 ;
10313 PyObject * obj1 = 0 ;
10314 char *kwnames[] = {
10315 (char *) "self",(char *) "mimetype", NULL
10316 };
10317
10318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10320 if (SWIG_arg_fail(1)) SWIG_fail;
10321 {
10322 arg2 = wxString_in_helper(obj1);
10323 if (arg2 == NULL) SWIG_fail;
10324 temp2 = true;
10325 }
10326 {
10327 PyThreadState* __tstate = wxPyBeginAllowThreads();
10328 (arg1)->SetMimeType((wxString const &)*arg2);
10329
10330 wxPyEndAllowThreads(__tstate);
10331 if (PyErr_Occurred()) SWIG_fail;
10332 }
10333 Py_INCREF(Py_None); resultobj = Py_None;
10334 {
10335 if (temp2)
10336 delete arg2;
10337 }
10338 return resultobj;
10339 fail:
10340 {
10341 if (temp2)
10342 delete arg2;
10343 }
10344 return NULL;
10345 }
10346
10347
10348 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10349 PyObject *obj;
10350 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10351 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10352 Py_INCREF(obj);
10353 return Py_BuildValue((char *)"");
10354 }
10355 static PyObject *_wrap_new_PyImageHandler(PyObject *, PyObject *args, PyObject *kwargs) {
10356 PyObject *resultobj = NULL;
10357 wxPyImageHandler *result;
10358 char *kwnames[] = {
10359 NULL
10360 };
10361
10362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyImageHandler",kwnames)) goto fail;
10363 {
10364 PyThreadState* __tstate = wxPyBeginAllowThreads();
10365 result = (wxPyImageHandler *)new wxPyImageHandler();
10366
10367 wxPyEndAllowThreads(__tstate);
10368 if (PyErr_Occurred()) SWIG_fail;
10369 }
10370 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyImageHandler, 1);
10371 return resultobj;
10372 fail:
10373 return NULL;
10374 }
10375
10376
10377 static PyObject *_wrap_PyImageHandler__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
10378 PyObject *resultobj = NULL;
10379 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
10380 PyObject *arg2 = (PyObject *) 0 ;
10381 PyObject * obj0 = 0 ;
10382 PyObject * obj1 = 0 ;
10383 char *kwnames[] = {
10384 (char *) "self",(char *) "self", NULL
10385 };
10386
10387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) goto fail;
10388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_EXCEPTION | 0);
10389 if (SWIG_arg_fail(1)) SWIG_fail;
10390 arg2 = obj1;
10391 {
10392 PyThreadState* __tstate = wxPyBeginAllowThreads();
10393 (arg1)->_SetSelf(arg2);
10394
10395 wxPyEndAllowThreads(__tstate);
10396 if (PyErr_Occurred()) SWIG_fail;
10397 }
10398 Py_INCREF(Py_None); resultobj = Py_None;
10399 return resultobj;
10400 fail:
10401 return NULL;
10402 }
10403
10404
10405 static PyObject * PyImageHandler_swigregister(PyObject *, PyObject *args) {
10406 PyObject *obj;
10407 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10408 SWIG_TypeClientData(SWIGTYPE_p_wxPyImageHandler, obj);
10409 Py_INCREF(obj);
10410 return Py_BuildValue((char *)"");
10411 }
10412 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10413 PyObject *resultobj = NULL;
10414 wxImageHistogram *result;
10415 char *kwnames[] = {
10416 NULL
10417 };
10418
10419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10420 {
10421 PyThreadState* __tstate = wxPyBeginAllowThreads();
10422 result = (wxImageHistogram *)new wxImageHistogram();
10423
10424 wxPyEndAllowThreads(__tstate);
10425 if (PyErr_Occurred()) SWIG_fail;
10426 }
10427 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10428 return resultobj;
10429 fail:
10430 return NULL;
10431 }
10432
10433
10434 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10435 PyObject *resultobj = NULL;
10436 byte arg1 ;
10437 byte arg2 ;
10438 byte arg3 ;
10439 unsigned long result;
10440 PyObject * obj0 = 0 ;
10441 PyObject * obj1 = 0 ;
10442 PyObject * obj2 = 0 ;
10443 char *kwnames[] = {
10444 (char *) "r",(char *) "g",(char *) "b", NULL
10445 };
10446
10447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10448 {
10449 arg1 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj0));
10450 if (SWIG_arg_fail(1)) SWIG_fail;
10451 }
10452 {
10453 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10454 if (SWIG_arg_fail(2)) SWIG_fail;
10455 }
10456 {
10457 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10458 if (SWIG_arg_fail(3)) SWIG_fail;
10459 }
10460 {
10461 PyThreadState* __tstate = wxPyBeginAllowThreads();
10462 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10463
10464 wxPyEndAllowThreads(__tstate);
10465 if (PyErr_Occurred()) SWIG_fail;
10466 }
10467 {
10468 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10469 }
10470 return resultobj;
10471 fail:
10472 return NULL;
10473 }
10474
10475
10476 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10477 PyObject *resultobj = NULL;
10478 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10479 byte *arg2 = (byte *) 0 ;
10480 byte *arg3 = (byte *) 0 ;
10481 byte *arg4 = (byte *) 0 ;
10482 byte arg5 = (byte) 1 ;
10483 byte arg6 = (byte) 0 ;
10484 byte arg7 = (byte) 0 ;
10485 bool result;
10486 byte temp2 ;
10487 int res2 = 0 ;
10488 byte temp3 ;
10489 int res3 = 0 ;
10490 byte temp4 ;
10491 int res4 = 0 ;
10492 PyObject * obj0 = 0 ;
10493 PyObject * obj1 = 0 ;
10494 PyObject * obj2 = 0 ;
10495 PyObject * obj3 = 0 ;
10496 char *kwnames[] = {
10497 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10498 };
10499
10500 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10501 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10502 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10505 if (SWIG_arg_fail(1)) SWIG_fail;
10506 if (obj1) {
10507 {
10508 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10509 if (SWIG_arg_fail(5)) SWIG_fail;
10510 }
10511 }
10512 if (obj2) {
10513 {
10514 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10515 if (SWIG_arg_fail(6)) SWIG_fail;
10516 }
10517 }
10518 if (obj3) {
10519 {
10520 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
10521 if (SWIG_arg_fail(7)) SWIG_fail;
10522 }
10523 }
10524 {
10525 PyThreadState* __tstate = wxPyBeginAllowThreads();
10526 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10527
10528 wxPyEndAllowThreads(__tstate);
10529 if (PyErr_Occurred()) SWIG_fail;
10530 }
10531 {
10532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10533 }
10534 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10535 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10536 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10537 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10538 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10539 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10540 return resultobj;
10541 fail:
10542 return NULL;
10543 }
10544
10545
10546 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10547 PyObject *resultobj = NULL;
10548 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10549 unsigned long arg2 ;
10550 unsigned long result;
10551 PyObject * obj0 = 0 ;
10552 PyObject * obj1 = 0 ;
10553 char *kwnames[] = {
10554 (char *) "self",(char *) "key", NULL
10555 };
10556
10557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10559 if (SWIG_arg_fail(1)) SWIG_fail;
10560 {
10561 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
10562 if (SWIG_arg_fail(2)) SWIG_fail;
10563 }
10564 {
10565 PyThreadState* __tstate = wxPyBeginAllowThreads();
10566 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10567
10568 wxPyEndAllowThreads(__tstate);
10569 if (PyErr_Occurred()) SWIG_fail;
10570 }
10571 {
10572 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10573 }
10574 return resultobj;
10575 fail:
10576 return NULL;
10577 }
10578
10579
10580 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10581 PyObject *resultobj = NULL;
10582 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10583 byte arg2 ;
10584 byte arg3 ;
10585 byte arg4 ;
10586 unsigned long result;
10587 PyObject * obj0 = 0 ;
10588 PyObject * obj1 = 0 ;
10589 PyObject * obj2 = 0 ;
10590 PyObject * obj3 = 0 ;
10591 char *kwnames[] = {
10592 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10593 };
10594
10595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10597 if (SWIG_arg_fail(1)) SWIG_fail;
10598 {
10599 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10600 if (SWIG_arg_fail(2)) SWIG_fail;
10601 }
10602 {
10603 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10604 if (SWIG_arg_fail(3)) SWIG_fail;
10605 }
10606 {
10607 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
10608 if (SWIG_arg_fail(4)) SWIG_fail;
10609 }
10610 {
10611 PyThreadState* __tstate = wxPyBeginAllowThreads();
10612 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10613
10614 wxPyEndAllowThreads(__tstate);
10615 if (PyErr_Occurred()) SWIG_fail;
10616 }
10617 {
10618 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10619 }
10620 return resultobj;
10621 fail:
10622 return NULL;
10623 }
10624
10625
10626 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10627 PyObject *resultobj = NULL;
10628 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10629 wxColour *arg2 = 0 ;
10630 unsigned long result;
10631 wxColour temp2 ;
10632 PyObject * obj0 = 0 ;
10633 PyObject * obj1 = 0 ;
10634 char *kwnames[] = {
10635 (char *) "self",(char *) "colour", NULL
10636 };
10637
10638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10640 if (SWIG_arg_fail(1)) SWIG_fail;
10641 {
10642 arg2 = &temp2;
10643 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10644 }
10645 {
10646 PyThreadState* __tstate = wxPyBeginAllowThreads();
10647 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10648
10649 wxPyEndAllowThreads(__tstate);
10650 if (PyErr_Occurred()) SWIG_fail;
10651 }
10652 {
10653 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
10654 }
10655 return resultobj;
10656 fail:
10657 return NULL;
10658 }
10659
10660
10661 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10662 PyObject *obj;
10663 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10664 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10665 Py_INCREF(obj);
10666 return Py_BuildValue((char *)"");
10667 }
10668 static PyObject *_wrap_new_Image_RGBValue(PyObject *, PyObject *args, PyObject *kwargs) {
10669 PyObject *resultobj = NULL;
10670 byte arg1 = (byte) 0 ;
10671 byte arg2 = (byte) 0 ;
10672 byte arg3 = (byte) 0 ;
10673 wxImage_RGBValue *result;
10674 PyObject * obj0 = 0 ;
10675 PyObject * obj1 = 0 ;
10676 PyObject * obj2 = 0 ;
10677 char *kwnames[] = {
10678 (char *) "r",(char *) "g",(char *) "b", NULL
10679 };
10680
10681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10682 if (obj0) {
10683 {
10684 arg1 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj0));
10685 if (SWIG_arg_fail(1)) SWIG_fail;
10686 }
10687 }
10688 if (obj1) {
10689 {
10690 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10691 if (SWIG_arg_fail(2)) SWIG_fail;
10692 }
10693 }
10694 if (obj2) {
10695 {
10696 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
10697 if (SWIG_arg_fail(3)) SWIG_fail;
10698 }
10699 }
10700 {
10701 PyThreadState* __tstate = wxPyBeginAllowThreads();
10702 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
10703
10704 wxPyEndAllowThreads(__tstate);
10705 if (PyErr_Occurred()) SWIG_fail;
10706 }
10707 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_RGBValue, 1);
10708 return resultobj;
10709 fail:
10710 return NULL;
10711 }
10712
10713
10714 static PyObject *_wrap_Image_RGBValue_red_set(PyObject *, PyObject *args, PyObject *kwargs) {
10715 PyObject *resultobj = NULL;
10716 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10717 byte arg2 ;
10718 PyObject * obj0 = 0 ;
10719 PyObject * obj1 = 0 ;
10720 char *kwnames[] = {
10721 (char *) "self",(char *) "red", NULL
10722 };
10723
10724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_red_set",kwnames,&obj0,&obj1)) goto fail;
10725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10726 if (SWIG_arg_fail(1)) SWIG_fail;
10727 {
10728 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10729 if (SWIG_arg_fail(2)) SWIG_fail;
10730 }
10731 if (arg1) (arg1)->red = arg2;
10732
10733 Py_INCREF(Py_None); resultobj = Py_None;
10734 return resultobj;
10735 fail:
10736 return NULL;
10737 }
10738
10739
10740 static PyObject *_wrap_Image_RGBValue_red_get(PyObject *, PyObject *args, PyObject *kwargs) {
10741 PyObject *resultobj = NULL;
10742 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10743 byte result;
10744 PyObject * obj0 = 0 ;
10745 char *kwnames[] = {
10746 (char *) "self", NULL
10747 };
10748
10749 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_red_get",kwnames,&obj0)) goto fail;
10750 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10751 if (SWIG_arg_fail(1)) SWIG_fail;
10752 result = (byte) ((arg1)->red);
10753
10754 {
10755 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10756 }
10757 return resultobj;
10758 fail:
10759 return NULL;
10760 }
10761
10762
10763 static PyObject *_wrap_Image_RGBValue_green_set(PyObject *, PyObject *args, PyObject *kwargs) {
10764 PyObject *resultobj = NULL;
10765 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10766 byte arg2 ;
10767 PyObject * obj0 = 0 ;
10768 PyObject * obj1 = 0 ;
10769 char *kwnames[] = {
10770 (char *) "self",(char *) "green", NULL
10771 };
10772
10773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_green_set",kwnames,&obj0,&obj1)) goto fail;
10774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10775 if (SWIG_arg_fail(1)) SWIG_fail;
10776 {
10777 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10778 if (SWIG_arg_fail(2)) SWIG_fail;
10779 }
10780 if (arg1) (arg1)->green = arg2;
10781
10782 Py_INCREF(Py_None); resultobj = Py_None;
10783 return resultobj;
10784 fail:
10785 return NULL;
10786 }
10787
10788
10789 static PyObject *_wrap_Image_RGBValue_green_get(PyObject *, PyObject *args, PyObject *kwargs) {
10790 PyObject *resultobj = NULL;
10791 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10792 byte result;
10793 PyObject * obj0 = 0 ;
10794 char *kwnames[] = {
10795 (char *) "self", NULL
10796 };
10797
10798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_green_get",kwnames,&obj0)) goto fail;
10799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10800 if (SWIG_arg_fail(1)) SWIG_fail;
10801 result = (byte) ((arg1)->green);
10802
10803 {
10804 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10805 }
10806 return resultobj;
10807 fail:
10808 return NULL;
10809 }
10810
10811
10812 static PyObject *_wrap_Image_RGBValue_blue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10813 PyObject *resultobj = NULL;
10814 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10815 byte arg2 ;
10816 PyObject * obj0 = 0 ;
10817 PyObject * obj1 = 0 ;
10818 char *kwnames[] = {
10819 (char *) "self",(char *) "blue", NULL
10820 };
10821
10822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_blue_set",kwnames,&obj0,&obj1)) goto fail;
10823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10824 if (SWIG_arg_fail(1)) SWIG_fail;
10825 {
10826 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
10827 if (SWIG_arg_fail(2)) SWIG_fail;
10828 }
10829 if (arg1) (arg1)->blue = arg2;
10830
10831 Py_INCREF(Py_None); resultobj = Py_None;
10832 return resultobj;
10833 fail:
10834 return NULL;
10835 }
10836
10837
10838 static PyObject *_wrap_Image_RGBValue_blue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10839 PyObject *resultobj = NULL;
10840 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10841 byte result;
10842 PyObject * obj0 = 0 ;
10843 char *kwnames[] = {
10844 (char *) "self", NULL
10845 };
10846
10847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_blue_get",kwnames,&obj0)) goto fail;
10848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10849 if (SWIG_arg_fail(1)) SWIG_fail;
10850 result = (byte) ((arg1)->blue);
10851
10852 {
10853 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
10854 }
10855 return resultobj;
10856 fail:
10857 return NULL;
10858 }
10859
10860
10861 static PyObject * Image_RGBValue_swigregister(PyObject *, PyObject *args) {
10862 PyObject *obj;
10863 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10864 SWIG_TypeClientData(SWIGTYPE_p_wxImage_RGBValue, obj);
10865 Py_INCREF(obj);
10866 return Py_BuildValue((char *)"");
10867 }
10868 static PyObject *_wrap_new_Image_HSVValue(PyObject *, PyObject *args, PyObject *kwargs) {
10869 PyObject *resultobj = NULL;
10870 double arg1 = (double) 0.0 ;
10871 double arg2 = (double) 0.0 ;
10872 double arg3 = (double) 0.0 ;
10873 wxImage_HSVValue *result;
10874 PyObject * obj0 = 0 ;
10875 PyObject * obj1 = 0 ;
10876 PyObject * obj2 = 0 ;
10877 char *kwnames[] = {
10878 (char *) "h",(char *) "s",(char *) "v", NULL
10879 };
10880
10881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10882 if (obj0) {
10883 {
10884 arg1 = static_cast<double >(SWIG_As_double(obj0));
10885 if (SWIG_arg_fail(1)) SWIG_fail;
10886 }
10887 }
10888 if (obj1) {
10889 {
10890 arg2 = static_cast<double >(SWIG_As_double(obj1));
10891 if (SWIG_arg_fail(2)) SWIG_fail;
10892 }
10893 }
10894 if (obj2) {
10895 {
10896 arg3 = static_cast<double >(SWIG_As_double(obj2));
10897 if (SWIG_arg_fail(3)) SWIG_fail;
10898 }
10899 }
10900 {
10901 PyThreadState* __tstate = wxPyBeginAllowThreads();
10902 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
10903
10904 wxPyEndAllowThreads(__tstate);
10905 if (PyErr_Occurred()) SWIG_fail;
10906 }
10907 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_HSVValue, 1);
10908 return resultobj;
10909 fail:
10910 return NULL;
10911 }
10912
10913
10914 static PyObject *_wrap_Image_HSVValue_hue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10915 PyObject *resultobj = NULL;
10916 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10917 double arg2 ;
10918 PyObject * obj0 = 0 ;
10919 PyObject * obj1 = 0 ;
10920 char *kwnames[] = {
10921 (char *) "self",(char *) "hue", NULL
10922 };
10923
10924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_hue_set",kwnames,&obj0,&obj1)) goto fail;
10925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10926 if (SWIG_arg_fail(1)) SWIG_fail;
10927 {
10928 arg2 = static_cast<double >(SWIG_As_double(obj1));
10929 if (SWIG_arg_fail(2)) SWIG_fail;
10930 }
10931 if (arg1) (arg1)->hue = arg2;
10932
10933 Py_INCREF(Py_None); resultobj = Py_None;
10934 return resultobj;
10935 fail:
10936 return NULL;
10937 }
10938
10939
10940 static PyObject *_wrap_Image_HSVValue_hue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10941 PyObject *resultobj = NULL;
10942 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10943 double result;
10944 PyObject * obj0 = 0 ;
10945 char *kwnames[] = {
10946 (char *) "self", NULL
10947 };
10948
10949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_hue_get",kwnames,&obj0)) goto fail;
10950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10951 if (SWIG_arg_fail(1)) SWIG_fail;
10952 result = (double) ((arg1)->hue);
10953
10954 {
10955 resultobj = SWIG_From_double(static_cast<double >(result));
10956 }
10957 return resultobj;
10958 fail:
10959 return NULL;
10960 }
10961
10962
10963 static PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *, PyObject *args, PyObject *kwargs) {
10964 PyObject *resultobj = NULL;
10965 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10966 double arg2 ;
10967 PyObject * obj0 = 0 ;
10968 PyObject * obj1 = 0 ;
10969 char *kwnames[] = {
10970 (char *) "self",(char *) "saturation", NULL
10971 };
10972
10973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_saturation_set",kwnames,&obj0,&obj1)) goto fail;
10974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10975 if (SWIG_arg_fail(1)) SWIG_fail;
10976 {
10977 arg2 = static_cast<double >(SWIG_As_double(obj1));
10978 if (SWIG_arg_fail(2)) SWIG_fail;
10979 }
10980 if (arg1) (arg1)->saturation = arg2;
10981
10982 Py_INCREF(Py_None); resultobj = Py_None;
10983 return resultobj;
10984 fail:
10985 return NULL;
10986 }
10987
10988
10989 static PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *, PyObject *args, PyObject *kwargs) {
10990 PyObject *resultobj = NULL;
10991 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10992 double result;
10993 PyObject * obj0 = 0 ;
10994 char *kwnames[] = {
10995 (char *) "self", NULL
10996 };
10997
10998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_saturation_get",kwnames,&obj0)) goto fail;
10999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11000 if (SWIG_arg_fail(1)) SWIG_fail;
11001 result = (double) ((arg1)->saturation);
11002
11003 {
11004 resultobj = SWIG_From_double(static_cast<double >(result));
11005 }
11006 return resultobj;
11007 fail:
11008 return NULL;
11009 }
11010
11011
11012 static PyObject *_wrap_Image_HSVValue_value_set(PyObject *, PyObject *args, PyObject *kwargs) {
11013 PyObject *resultobj = NULL;
11014 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11015 double arg2 ;
11016 PyObject * obj0 = 0 ;
11017 PyObject * obj1 = 0 ;
11018 char *kwnames[] = {
11019 (char *) "self",(char *) "value", NULL
11020 };
11021
11022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_value_set",kwnames,&obj0,&obj1)) goto fail;
11023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11024 if (SWIG_arg_fail(1)) SWIG_fail;
11025 {
11026 arg2 = static_cast<double >(SWIG_As_double(obj1));
11027 if (SWIG_arg_fail(2)) SWIG_fail;
11028 }
11029 if (arg1) (arg1)->value = arg2;
11030
11031 Py_INCREF(Py_None); resultobj = Py_None;
11032 return resultobj;
11033 fail:
11034 return NULL;
11035 }
11036
11037
11038 static PyObject *_wrap_Image_HSVValue_value_get(PyObject *, PyObject *args, PyObject *kwargs) {
11039 PyObject *resultobj = NULL;
11040 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
11041 double result;
11042 PyObject * obj0 = 0 ;
11043 char *kwnames[] = {
11044 (char *) "self", NULL
11045 };
11046
11047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_value_get",kwnames,&obj0)) goto fail;
11048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
11049 if (SWIG_arg_fail(1)) SWIG_fail;
11050 result = (double) ((arg1)->value);
11051
11052 {
11053 resultobj = SWIG_From_double(static_cast<double >(result));
11054 }
11055 return resultobj;
11056 fail:
11057 return NULL;
11058 }
11059
11060
11061 static PyObject * Image_HSVValue_swigregister(PyObject *, PyObject *args) {
11062 PyObject *obj;
11063 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
11064 SWIG_TypeClientData(SWIGTYPE_p_wxImage_HSVValue, obj);
11065 Py_INCREF(obj);
11066 return Py_BuildValue((char *)"");
11067 }
11068 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11069 PyObject *resultobj = NULL;
11070 wxString *arg1 = 0 ;
11071 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11072 int arg3 = (int) -1 ;
11073 wxImage *result;
11074 bool temp1 = false ;
11075 PyObject * obj0 = 0 ;
11076 PyObject * obj1 = 0 ;
11077 PyObject * obj2 = 0 ;
11078 char *kwnames[] = {
11079 (char *) "name",(char *) "type",(char *) "index", NULL
11080 };
11081
11082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
11083 {
11084 arg1 = wxString_in_helper(obj0);
11085 if (arg1 == NULL) SWIG_fail;
11086 temp1 = true;
11087 }
11088 if (obj1) {
11089 {
11090 arg2 = static_cast<long >(SWIG_As_long(obj1));
11091 if (SWIG_arg_fail(2)) SWIG_fail;
11092 }
11093 }
11094 if (obj2) {
11095 {
11096 arg3 = static_cast<int >(SWIG_As_int(obj2));
11097 if (SWIG_arg_fail(3)) SWIG_fail;
11098 }
11099 }
11100 {
11101 PyThreadState* __tstate = wxPyBeginAllowThreads();
11102 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
11103
11104 wxPyEndAllowThreads(__tstate);
11105 if (PyErr_Occurred()) SWIG_fail;
11106 }
11107 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11108 {
11109 if (temp1)
11110 delete arg1;
11111 }
11112 return resultobj;
11113 fail:
11114 {
11115 if (temp1)
11116 delete arg1;
11117 }
11118 return NULL;
11119 }
11120
11121
11122 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
11123 PyObject *resultobj = NULL;
11124 wxImage *arg1 = (wxImage *) 0 ;
11125 PyObject * obj0 = 0 ;
11126 char *kwnames[] = {
11127 (char *) "self", NULL
11128 };
11129
11130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
11131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11132 if (SWIG_arg_fail(1)) SWIG_fail;
11133 {
11134 PyThreadState* __tstate = wxPyBeginAllowThreads();
11135 delete arg1;
11136
11137 wxPyEndAllowThreads(__tstate);
11138 if (PyErr_Occurred()) SWIG_fail;
11139 }
11140 Py_INCREF(Py_None); resultobj = Py_None;
11141 return resultobj;
11142 fail:
11143 return NULL;
11144 }
11145
11146
11147 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
11148 PyObject *resultobj = NULL;
11149 wxString *arg1 = 0 ;
11150 wxString *arg2 = 0 ;
11151 int arg3 = (int) -1 ;
11152 wxImage *result;
11153 bool temp1 = false ;
11154 bool temp2 = false ;
11155 PyObject * obj0 = 0 ;
11156 PyObject * obj1 = 0 ;
11157 PyObject * obj2 = 0 ;
11158 char *kwnames[] = {
11159 (char *) "name",(char *) "mimetype",(char *) "index", NULL
11160 };
11161
11162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11163 {
11164 arg1 = wxString_in_helper(obj0);
11165 if (arg1 == NULL) SWIG_fail;
11166 temp1 = true;
11167 }
11168 {
11169 arg2 = wxString_in_helper(obj1);
11170 if (arg2 == NULL) SWIG_fail;
11171 temp2 = true;
11172 }
11173 if (obj2) {
11174 {
11175 arg3 = static_cast<int >(SWIG_As_int(obj2));
11176 if (SWIG_arg_fail(3)) SWIG_fail;
11177 }
11178 }
11179 {
11180 PyThreadState* __tstate = wxPyBeginAllowThreads();
11181 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
11182
11183 wxPyEndAllowThreads(__tstate);
11184 if (PyErr_Occurred()) SWIG_fail;
11185 }
11186 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11187 {
11188 if (temp1)
11189 delete arg1;
11190 }
11191 {
11192 if (temp2)
11193 delete arg2;
11194 }
11195 return resultobj;
11196 fail:
11197 {
11198 if (temp1)
11199 delete arg1;
11200 }
11201 {
11202 if (temp2)
11203 delete arg2;
11204 }
11205 return NULL;
11206 }
11207
11208
11209 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
11210 PyObject *resultobj = NULL;
11211 wxInputStream *arg1 = 0 ;
11212 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11213 int arg3 = (int) -1 ;
11214 wxImage *result;
11215 wxPyInputStream *temp1 ;
11216 bool created1 ;
11217 PyObject * obj0 = 0 ;
11218 PyObject * obj1 = 0 ;
11219 PyObject * obj2 = 0 ;
11220 char *kwnames[] = {
11221 (char *) "stream",(char *) "type",(char *) "index", NULL
11222 };
11223
11224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
11225 {
11226 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11227 arg1 = temp1->m_wxis;
11228 created1 = false;
11229 } else {
11230 PyErr_Clear(); // clear the failure of the wxPyConvert above
11231 arg1 = wxPyCBInputStream_create(obj0, false);
11232 if (arg1 == NULL) {
11233 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11234 SWIG_fail;
11235 }
11236 created1 = true;
11237 }
11238 }
11239 if (obj1) {
11240 {
11241 arg2 = static_cast<long >(SWIG_As_long(obj1));
11242 if (SWIG_arg_fail(2)) SWIG_fail;
11243 }
11244 }
11245 if (obj2) {
11246 {
11247 arg3 = static_cast<int >(SWIG_As_int(obj2));
11248 if (SWIG_arg_fail(3)) SWIG_fail;
11249 }
11250 }
11251 {
11252 PyThreadState* __tstate = wxPyBeginAllowThreads();
11253 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
11254
11255 wxPyEndAllowThreads(__tstate);
11256 if (PyErr_Occurred()) SWIG_fail;
11257 }
11258 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11259 {
11260 if (created1) delete arg1;
11261 }
11262 return resultobj;
11263 fail:
11264 {
11265 if (created1) delete arg1;
11266 }
11267 return NULL;
11268 }
11269
11270
11271 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
11272 PyObject *resultobj = NULL;
11273 wxInputStream *arg1 = 0 ;
11274 wxString *arg2 = 0 ;
11275 int arg3 = (int) -1 ;
11276 wxImage *result;
11277 wxPyInputStream *temp1 ;
11278 bool created1 ;
11279 bool temp2 = false ;
11280 PyObject * obj0 = 0 ;
11281 PyObject * obj1 = 0 ;
11282 PyObject * obj2 = 0 ;
11283 char *kwnames[] = {
11284 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
11285 };
11286
11287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11288 {
11289 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11290 arg1 = temp1->m_wxis;
11291 created1 = false;
11292 } else {
11293 PyErr_Clear(); // clear the failure of the wxPyConvert above
11294 arg1 = wxPyCBInputStream_create(obj0, false);
11295 if (arg1 == NULL) {
11296 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11297 SWIG_fail;
11298 }
11299 created1 = true;
11300 }
11301 }
11302 {
11303 arg2 = wxString_in_helper(obj1);
11304 if (arg2 == NULL) SWIG_fail;
11305 temp2 = true;
11306 }
11307 if (obj2) {
11308 {
11309 arg3 = static_cast<int >(SWIG_As_int(obj2));
11310 if (SWIG_arg_fail(3)) SWIG_fail;
11311 }
11312 }
11313 {
11314 PyThreadState* __tstate = wxPyBeginAllowThreads();
11315 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
11316
11317 wxPyEndAllowThreads(__tstate);
11318 if (PyErr_Occurred()) SWIG_fail;
11319 }
11320 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11321 {
11322 if (created1) delete arg1;
11323 }
11324 {
11325 if (temp2)
11326 delete arg2;
11327 }
11328 return resultobj;
11329 fail:
11330 {
11331 if (created1) delete arg1;
11332 }
11333 {
11334 if (temp2)
11335 delete arg2;
11336 }
11337 return NULL;
11338 }
11339
11340
11341 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
11342 PyObject *resultobj = NULL;
11343 int arg1 = (int) 0 ;
11344 int arg2 = (int) 0 ;
11345 bool arg3 = (bool) true ;
11346 wxImage *result;
11347 PyObject * obj0 = 0 ;
11348 PyObject * obj1 = 0 ;
11349 PyObject * obj2 = 0 ;
11350 char *kwnames[] = {
11351 (char *) "width",(char *) "height",(char *) "clear", NULL
11352 };
11353
11354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
11355 if (obj0) {
11356 {
11357 arg1 = static_cast<int >(SWIG_As_int(obj0));
11358 if (SWIG_arg_fail(1)) SWIG_fail;
11359 }
11360 }
11361 if (obj1) {
11362 {
11363 arg2 = static_cast<int >(SWIG_As_int(obj1));
11364 if (SWIG_arg_fail(2)) SWIG_fail;
11365 }
11366 }
11367 if (obj2) {
11368 {
11369 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
11370 if (SWIG_arg_fail(3)) SWIG_fail;
11371 }
11372 }
11373 {
11374 PyThreadState* __tstate = wxPyBeginAllowThreads();
11375 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
11376
11377 wxPyEndAllowThreads(__tstate);
11378 if (PyErr_Occurred()) SWIG_fail;
11379 }
11380 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11381 return resultobj;
11382 fail:
11383 return NULL;
11384 }
11385
11386
11387 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
11388 PyObject *resultobj = NULL;
11389 wxBitmap *arg1 = 0 ;
11390 wxImage *result;
11391 PyObject * obj0 = 0 ;
11392 char *kwnames[] = {
11393 (char *) "bitmap", NULL
11394 };
11395
11396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
11397 {
11398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
11399 if (SWIG_arg_fail(1)) SWIG_fail;
11400 if (arg1 == NULL) {
11401 SWIG_null_ref("wxBitmap");
11402 }
11403 if (SWIG_arg_fail(1)) SWIG_fail;
11404 }
11405 {
11406 if (!wxPyCheckForApp()) SWIG_fail;
11407 PyThreadState* __tstate = wxPyBeginAllowThreads();
11408 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
11409
11410 wxPyEndAllowThreads(__tstate);
11411 if (PyErr_Occurred()) SWIG_fail;
11412 }
11413 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11414 return resultobj;
11415 fail:
11416 return NULL;
11417 }
11418
11419
11420 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
11421 PyObject *resultobj = NULL;
11422 int arg1 ;
11423 int arg2 ;
11424 buffer arg3 ;
11425 int arg4 ;
11426 wxImage *result;
11427 PyObject * obj0 = 0 ;
11428 PyObject * obj1 = 0 ;
11429 PyObject * obj2 = 0 ;
11430 char *kwnames[] = {
11431 (char *) "width",(char *) "height",(char *) "data", NULL
11432 };
11433
11434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
11435 {
11436 arg1 = static_cast<int >(SWIG_As_int(obj0));
11437 if (SWIG_arg_fail(1)) SWIG_fail;
11438 }
11439 {
11440 arg2 = static_cast<int >(SWIG_As_int(obj1));
11441 if (SWIG_arg_fail(2)) SWIG_fail;
11442 }
11443 {
11444 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11445 }
11446 {
11447 PyThreadState* __tstate = wxPyBeginAllowThreads();
11448 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
11449
11450 wxPyEndAllowThreads(__tstate);
11451 if (PyErr_Occurred()) SWIG_fail;
11452 }
11453 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11454 return resultobj;
11455 fail:
11456 return NULL;
11457 }
11458
11459
11460 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11461 PyObject *resultobj = NULL;
11462 int arg1 ;
11463 int arg2 ;
11464 buffer arg3 ;
11465 int arg4 ;
11466 buffer arg5 ;
11467 int arg6 ;
11468 wxImage *result;
11469 PyObject * obj0 = 0 ;
11470 PyObject * obj1 = 0 ;
11471 PyObject * obj2 = 0 ;
11472 PyObject * obj3 = 0 ;
11473 char *kwnames[] = {
11474 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
11475 };
11476
11477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11478 {
11479 arg1 = static_cast<int >(SWIG_As_int(obj0));
11480 if (SWIG_arg_fail(1)) SWIG_fail;
11481 }
11482 {
11483 arg2 = static_cast<int >(SWIG_As_int(obj1));
11484 if (SWIG_arg_fail(2)) SWIG_fail;
11485 }
11486 {
11487 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11488 }
11489 {
11490 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
11491 }
11492 {
11493 PyThreadState* __tstate = wxPyBeginAllowThreads();
11494 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
11495
11496 wxPyEndAllowThreads(__tstate);
11497 if (PyErr_Occurred()) SWIG_fail;
11498 }
11499 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11500 return resultobj;
11501 fail:
11502 return NULL;
11503 }
11504
11505
11506 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11507 PyObject *resultobj = NULL;
11508 wxImage *arg1 = (wxImage *) 0 ;
11509 int arg2 ;
11510 int arg3 ;
11511 bool arg4 = (bool) true ;
11512 PyObject * obj0 = 0 ;
11513 PyObject * obj1 = 0 ;
11514 PyObject * obj2 = 0 ;
11515 PyObject * obj3 = 0 ;
11516 char *kwnames[] = {
11517 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
11518 };
11519
11520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11522 if (SWIG_arg_fail(1)) SWIG_fail;
11523 {
11524 arg2 = static_cast<int >(SWIG_As_int(obj1));
11525 if (SWIG_arg_fail(2)) SWIG_fail;
11526 }
11527 {
11528 arg3 = static_cast<int >(SWIG_As_int(obj2));
11529 if (SWIG_arg_fail(3)) SWIG_fail;
11530 }
11531 if (obj3) {
11532 {
11533 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
11534 if (SWIG_arg_fail(4)) SWIG_fail;
11535 }
11536 }
11537 {
11538 PyThreadState* __tstate = wxPyBeginAllowThreads();
11539 (arg1)->Create(arg2,arg3,arg4);
11540
11541 wxPyEndAllowThreads(__tstate);
11542 if (PyErr_Occurred()) SWIG_fail;
11543 }
11544 Py_INCREF(Py_None); resultobj = Py_None;
11545 return resultobj;
11546 fail:
11547 return NULL;
11548 }
11549
11550
11551 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
11552 PyObject *resultobj = NULL;
11553 wxImage *arg1 = (wxImage *) 0 ;
11554 PyObject * obj0 = 0 ;
11555 char *kwnames[] = {
11556 (char *) "self", NULL
11557 };
11558
11559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
11560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11561 if (SWIG_arg_fail(1)) SWIG_fail;
11562 {
11563 PyThreadState* __tstate = wxPyBeginAllowThreads();
11564 (arg1)->Destroy();
11565
11566 wxPyEndAllowThreads(__tstate);
11567 if (PyErr_Occurred()) SWIG_fail;
11568 }
11569 Py_INCREF(Py_None); resultobj = Py_None;
11570 return resultobj;
11571 fail:
11572 return NULL;
11573 }
11574
11575
11576 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
11577 PyObject *resultobj = NULL;
11578 wxImage *arg1 = (wxImage *) 0 ;
11579 int arg2 ;
11580 int arg3 ;
11581 SwigValueWrapper<wxImage > result;
11582 PyObject * obj0 = 0 ;
11583 PyObject * obj1 = 0 ;
11584 PyObject * obj2 = 0 ;
11585 char *kwnames[] = {
11586 (char *) "self",(char *) "width",(char *) "height", NULL
11587 };
11588
11589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11591 if (SWIG_arg_fail(1)) SWIG_fail;
11592 {
11593 arg2 = static_cast<int >(SWIG_As_int(obj1));
11594 if (SWIG_arg_fail(2)) SWIG_fail;
11595 }
11596 {
11597 arg3 = static_cast<int >(SWIG_As_int(obj2));
11598 if (SWIG_arg_fail(3)) SWIG_fail;
11599 }
11600 {
11601 PyThreadState* __tstate = wxPyBeginAllowThreads();
11602 result = (arg1)->Scale(arg2,arg3);
11603
11604 wxPyEndAllowThreads(__tstate);
11605 if (PyErr_Occurred()) SWIG_fail;
11606 }
11607 {
11608 wxImage * resultptr;
11609 resultptr = new wxImage(static_cast<wxImage & >(result));
11610 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11611 }
11612 return resultobj;
11613 fail:
11614 return NULL;
11615 }
11616
11617
11618 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11619 PyObject *resultobj = NULL;
11620 wxImage *arg1 = (wxImage *) 0 ;
11621 int arg2 ;
11622 int arg3 ;
11623 SwigValueWrapper<wxImage > result;
11624 PyObject * obj0 = 0 ;
11625 PyObject * obj1 = 0 ;
11626 PyObject * obj2 = 0 ;
11627 char *kwnames[] = {
11628 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11629 };
11630
11631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11633 if (SWIG_arg_fail(1)) SWIG_fail;
11634 {
11635 arg2 = static_cast<int >(SWIG_As_int(obj1));
11636 if (SWIG_arg_fail(2)) SWIG_fail;
11637 }
11638 {
11639 arg3 = static_cast<int >(SWIG_As_int(obj2));
11640 if (SWIG_arg_fail(3)) SWIG_fail;
11641 }
11642 {
11643 PyThreadState* __tstate = wxPyBeginAllowThreads();
11644 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11645
11646 wxPyEndAllowThreads(__tstate);
11647 if (PyErr_Occurred()) SWIG_fail;
11648 }
11649 {
11650 wxImage * resultptr;
11651 resultptr = new wxImage(static_cast<wxImage & >(result));
11652 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11653 }
11654 return resultobj;
11655 fail:
11656 return NULL;
11657 }
11658
11659
11660 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11661 PyObject *resultobj = NULL;
11662 wxImage *arg1 = (wxImage *) 0 ;
11663 int arg2 ;
11664 int arg3 ;
11665 wxImage *result;
11666 PyObject * obj0 = 0 ;
11667 PyObject * obj1 = 0 ;
11668 PyObject * obj2 = 0 ;
11669 char *kwnames[] = {
11670 (char *) "self",(char *) "width",(char *) "height", NULL
11671 };
11672
11673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11675 if (SWIG_arg_fail(1)) SWIG_fail;
11676 {
11677 arg2 = static_cast<int >(SWIG_As_int(obj1));
11678 if (SWIG_arg_fail(2)) SWIG_fail;
11679 }
11680 {
11681 arg3 = static_cast<int >(SWIG_As_int(obj2));
11682 if (SWIG_arg_fail(3)) SWIG_fail;
11683 }
11684 {
11685 PyThreadState* __tstate = wxPyBeginAllowThreads();
11686 {
11687 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11688 result = (wxImage *) &_result_ref;
11689 }
11690
11691 wxPyEndAllowThreads(__tstate);
11692 if (PyErr_Occurred()) SWIG_fail;
11693 }
11694 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11695 return resultobj;
11696 fail:
11697 return NULL;
11698 }
11699
11700
11701 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11702 PyObject *resultobj = NULL;
11703 wxImage *arg1 = (wxImage *) 0 ;
11704 wxSize *arg2 = 0 ;
11705 wxPoint *arg3 = 0 ;
11706 int arg4 = (int) -1 ;
11707 int arg5 = (int) -1 ;
11708 int arg6 = (int) -1 ;
11709 wxImage *result;
11710 wxSize temp2 ;
11711 wxPoint temp3 ;
11712 PyObject * obj0 = 0 ;
11713 PyObject * obj1 = 0 ;
11714 PyObject * obj2 = 0 ;
11715 PyObject * obj3 = 0 ;
11716 PyObject * obj4 = 0 ;
11717 PyObject * obj5 = 0 ;
11718 char *kwnames[] = {
11719 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11720 };
11721
11722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11724 if (SWIG_arg_fail(1)) SWIG_fail;
11725 {
11726 arg2 = &temp2;
11727 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11728 }
11729 {
11730 arg3 = &temp3;
11731 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11732 }
11733 if (obj3) {
11734 {
11735 arg4 = static_cast<int >(SWIG_As_int(obj3));
11736 if (SWIG_arg_fail(4)) SWIG_fail;
11737 }
11738 }
11739 if (obj4) {
11740 {
11741 arg5 = static_cast<int >(SWIG_As_int(obj4));
11742 if (SWIG_arg_fail(5)) SWIG_fail;
11743 }
11744 }
11745 if (obj5) {
11746 {
11747 arg6 = static_cast<int >(SWIG_As_int(obj5));
11748 if (SWIG_arg_fail(6)) SWIG_fail;
11749 }
11750 }
11751 {
11752 PyThreadState* __tstate = wxPyBeginAllowThreads();
11753 {
11754 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11755 result = (wxImage *) &_result_ref;
11756 }
11757
11758 wxPyEndAllowThreads(__tstate);
11759 if (PyErr_Occurred()) SWIG_fail;
11760 }
11761 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11762 return resultobj;
11763 fail:
11764 return NULL;
11765 }
11766
11767
11768 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11769 PyObject *resultobj = NULL;
11770 wxImage *arg1 = (wxImage *) 0 ;
11771 int arg2 ;
11772 int arg3 ;
11773 byte arg4 ;
11774 byte arg5 ;
11775 byte arg6 ;
11776 PyObject * obj0 = 0 ;
11777 PyObject * obj1 = 0 ;
11778 PyObject * obj2 = 0 ;
11779 PyObject * obj3 = 0 ;
11780 PyObject * obj4 = 0 ;
11781 PyObject * obj5 = 0 ;
11782 char *kwnames[] = {
11783 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11784 };
11785
11786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11788 if (SWIG_arg_fail(1)) SWIG_fail;
11789 {
11790 arg2 = static_cast<int >(SWIG_As_int(obj1));
11791 if (SWIG_arg_fail(2)) SWIG_fail;
11792 }
11793 {
11794 arg3 = static_cast<int >(SWIG_As_int(obj2));
11795 if (SWIG_arg_fail(3)) SWIG_fail;
11796 }
11797 {
11798 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
11799 if (SWIG_arg_fail(4)) SWIG_fail;
11800 }
11801 {
11802 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
11803 if (SWIG_arg_fail(5)) SWIG_fail;
11804 }
11805 {
11806 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj5));
11807 if (SWIG_arg_fail(6)) SWIG_fail;
11808 }
11809 {
11810 PyThreadState* __tstate = wxPyBeginAllowThreads();
11811 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11812
11813 wxPyEndAllowThreads(__tstate);
11814 if (PyErr_Occurred()) SWIG_fail;
11815 }
11816 Py_INCREF(Py_None); resultobj = Py_None;
11817 return resultobj;
11818 fail:
11819 return NULL;
11820 }
11821
11822
11823 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11824 PyObject *resultobj = NULL;
11825 wxImage *arg1 = (wxImage *) 0 ;
11826 wxRect *arg2 = 0 ;
11827 byte arg3 ;
11828 byte arg4 ;
11829 byte arg5 ;
11830 wxRect temp2 ;
11831 PyObject * obj0 = 0 ;
11832 PyObject * obj1 = 0 ;
11833 PyObject * obj2 = 0 ;
11834 PyObject * obj3 = 0 ;
11835 PyObject * obj4 = 0 ;
11836 char *kwnames[] = {
11837 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11838 };
11839
11840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11842 if (SWIG_arg_fail(1)) SWIG_fail;
11843 {
11844 arg2 = &temp2;
11845 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11846 }
11847 {
11848 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
11849 if (SWIG_arg_fail(3)) SWIG_fail;
11850 }
11851 {
11852 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
11853 if (SWIG_arg_fail(4)) SWIG_fail;
11854 }
11855 {
11856 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
11857 if (SWIG_arg_fail(5)) SWIG_fail;
11858 }
11859 {
11860 PyThreadState* __tstate = wxPyBeginAllowThreads();
11861 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11862
11863 wxPyEndAllowThreads(__tstate);
11864 if (PyErr_Occurred()) SWIG_fail;
11865 }
11866 Py_INCREF(Py_None); resultobj = Py_None;
11867 return resultobj;
11868 fail:
11869 return NULL;
11870 }
11871
11872
11873 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11874 PyObject *resultobj = NULL;
11875 wxImage *arg1 = (wxImage *) 0 ;
11876 int arg2 ;
11877 int arg3 ;
11878 byte result;
11879 PyObject * obj0 = 0 ;
11880 PyObject * obj1 = 0 ;
11881 PyObject * obj2 = 0 ;
11882 char *kwnames[] = {
11883 (char *) "self",(char *) "x",(char *) "y", NULL
11884 };
11885
11886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11888 if (SWIG_arg_fail(1)) SWIG_fail;
11889 {
11890 arg2 = static_cast<int >(SWIG_As_int(obj1));
11891 if (SWIG_arg_fail(2)) SWIG_fail;
11892 }
11893 {
11894 arg3 = static_cast<int >(SWIG_As_int(obj2));
11895 if (SWIG_arg_fail(3)) SWIG_fail;
11896 }
11897 {
11898 PyThreadState* __tstate = wxPyBeginAllowThreads();
11899 result = (byte)(arg1)->GetRed(arg2,arg3);
11900
11901 wxPyEndAllowThreads(__tstate);
11902 if (PyErr_Occurred()) SWIG_fail;
11903 }
11904 {
11905 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
11906 }
11907 return resultobj;
11908 fail:
11909 return NULL;
11910 }
11911
11912
11913 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11914 PyObject *resultobj = NULL;
11915 wxImage *arg1 = (wxImage *) 0 ;
11916 int arg2 ;
11917 int arg3 ;
11918 byte result;
11919 PyObject * obj0 = 0 ;
11920 PyObject * obj1 = 0 ;
11921 PyObject * obj2 = 0 ;
11922 char *kwnames[] = {
11923 (char *) "self",(char *) "x",(char *) "y", NULL
11924 };
11925
11926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11928 if (SWIG_arg_fail(1)) SWIG_fail;
11929 {
11930 arg2 = static_cast<int >(SWIG_As_int(obj1));
11931 if (SWIG_arg_fail(2)) SWIG_fail;
11932 }
11933 {
11934 arg3 = static_cast<int >(SWIG_As_int(obj2));
11935 if (SWIG_arg_fail(3)) SWIG_fail;
11936 }
11937 {
11938 PyThreadState* __tstate = wxPyBeginAllowThreads();
11939 result = (byte)(arg1)->GetGreen(arg2,arg3);
11940
11941 wxPyEndAllowThreads(__tstate);
11942 if (PyErr_Occurred()) SWIG_fail;
11943 }
11944 {
11945 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
11946 }
11947 return resultobj;
11948 fail:
11949 return NULL;
11950 }
11951
11952
11953 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11954 PyObject *resultobj = NULL;
11955 wxImage *arg1 = (wxImage *) 0 ;
11956 int arg2 ;
11957 int arg3 ;
11958 byte result;
11959 PyObject * obj0 = 0 ;
11960 PyObject * obj1 = 0 ;
11961 PyObject * obj2 = 0 ;
11962 char *kwnames[] = {
11963 (char *) "self",(char *) "x",(char *) "y", NULL
11964 };
11965
11966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11968 if (SWIG_arg_fail(1)) SWIG_fail;
11969 {
11970 arg2 = static_cast<int >(SWIG_As_int(obj1));
11971 if (SWIG_arg_fail(2)) SWIG_fail;
11972 }
11973 {
11974 arg3 = static_cast<int >(SWIG_As_int(obj2));
11975 if (SWIG_arg_fail(3)) SWIG_fail;
11976 }
11977 {
11978 PyThreadState* __tstate = wxPyBeginAllowThreads();
11979 result = (byte)(arg1)->GetBlue(arg2,arg3);
11980
11981 wxPyEndAllowThreads(__tstate);
11982 if (PyErr_Occurred()) SWIG_fail;
11983 }
11984 {
11985 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
11986 }
11987 return resultobj;
11988 fail:
11989 return NULL;
11990 }
11991
11992
11993 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11994 PyObject *resultobj = NULL;
11995 wxImage *arg1 = (wxImage *) 0 ;
11996 int arg2 ;
11997 int arg3 ;
11998 byte arg4 ;
11999 PyObject * obj0 = 0 ;
12000 PyObject * obj1 = 0 ;
12001 PyObject * obj2 = 0 ;
12002 PyObject * obj3 = 0 ;
12003 char *kwnames[] = {
12004 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
12005 };
12006
12007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12009 if (SWIG_arg_fail(1)) SWIG_fail;
12010 {
12011 arg2 = static_cast<int >(SWIG_As_int(obj1));
12012 if (SWIG_arg_fail(2)) SWIG_fail;
12013 }
12014 {
12015 arg3 = static_cast<int >(SWIG_As_int(obj2));
12016 if (SWIG_arg_fail(3)) SWIG_fail;
12017 }
12018 {
12019 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12020 if (SWIG_arg_fail(4)) SWIG_fail;
12021 }
12022 {
12023 PyThreadState* __tstate = wxPyBeginAllowThreads();
12024 (arg1)->SetAlpha(arg2,arg3,arg4);
12025
12026 wxPyEndAllowThreads(__tstate);
12027 if (PyErr_Occurred()) SWIG_fail;
12028 }
12029 Py_INCREF(Py_None); resultobj = Py_None;
12030 return resultobj;
12031 fail:
12032 return NULL;
12033 }
12034
12035
12036 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12037 PyObject *resultobj = NULL;
12038 wxImage *arg1 = (wxImage *) 0 ;
12039 int arg2 ;
12040 int arg3 ;
12041 byte result;
12042 PyObject * obj0 = 0 ;
12043 PyObject * obj1 = 0 ;
12044 PyObject * obj2 = 0 ;
12045 char *kwnames[] = {
12046 (char *) "self",(char *) "x",(char *) "y", NULL
12047 };
12048
12049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
12050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12051 if (SWIG_arg_fail(1)) SWIG_fail;
12052 {
12053 arg2 = static_cast<int >(SWIG_As_int(obj1));
12054 if (SWIG_arg_fail(2)) SWIG_fail;
12055 }
12056 {
12057 arg3 = static_cast<int >(SWIG_As_int(obj2));
12058 if (SWIG_arg_fail(3)) SWIG_fail;
12059 }
12060 {
12061 PyThreadState* __tstate = wxPyBeginAllowThreads();
12062 result = (byte)(arg1)->GetAlpha(arg2,arg3);
12063
12064 wxPyEndAllowThreads(__tstate);
12065 if (PyErr_Occurred()) SWIG_fail;
12066 }
12067 {
12068 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
12069 }
12070 return resultobj;
12071 fail:
12072 return NULL;
12073 }
12074
12075
12076 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12077 PyObject *resultobj = NULL;
12078 wxImage *arg1 = (wxImage *) 0 ;
12079 bool result;
12080 PyObject * obj0 = 0 ;
12081 char *kwnames[] = {
12082 (char *) "self", NULL
12083 };
12084
12085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
12086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12087 if (SWIG_arg_fail(1)) SWIG_fail;
12088 {
12089 PyThreadState* __tstate = wxPyBeginAllowThreads();
12090 result = (bool)(arg1)->HasAlpha();
12091
12092 wxPyEndAllowThreads(__tstate);
12093 if (PyErr_Occurred()) SWIG_fail;
12094 }
12095 {
12096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12097 }
12098 return resultobj;
12099 fail:
12100 return NULL;
12101 }
12102
12103
12104 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12105 PyObject *resultobj = NULL;
12106 wxImage *arg1 = (wxImage *) 0 ;
12107 PyObject * obj0 = 0 ;
12108 char *kwnames[] = {
12109 (char *) "self", NULL
12110 };
12111
12112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
12113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12114 if (SWIG_arg_fail(1)) SWIG_fail;
12115 {
12116 PyThreadState* __tstate = wxPyBeginAllowThreads();
12117 (arg1)->InitAlpha();
12118
12119 wxPyEndAllowThreads(__tstate);
12120 if (PyErr_Occurred()) SWIG_fail;
12121 }
12122 Py_INCREF(Py_None); resultobj = Py_None;
12123 return resultobj;
12124 fail:
12125 return NULL;
12126 }
12127
12128
12129 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
12130 PyObject *resultobj = NULL;
12131 wxImage *arg1 = (wxImage *) 0 ;
12132 int arg2 ;
12133 int arg3 ;
12134 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12135 bool result;
12136 PyObject * obj0 = 0 ;
12137 PyObject * obj1 = 0 ;
12138 PyObject * obj2 = 0 ;
12139 PyObject * obj3 = 0 ;
12140 char *kwnames[] = {
12141 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
12142 };
12143
12144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12146 if (SWIG_arg_fail(1)) SWIG_fail;
12147 {
12148 arg2 = static_cast<int >(SWIG_As_int(obj1));
12149 if (SWIG_arg_fail(2)) SWIG_fail;
12150 }
12151 {
12152 arg3 = static_cast<int >(SWIG_As_int(obj2));
12153 if (SWIG_arg_fail(3)) SWIG_fail;
12154 }
12155 if (obj3) {
12156 {
12157 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12158 if (SWIG_arg_fail(4)) SWIG_fail;
12159 }
12160 }
12161 {
12162 PyThreadState* __tstate = wxPyBeginAllowThreads();
12163 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
12164
12165 wxPyEndAllowThreads(__tstate);
12166 if (PyErr_Occurred()) SWIG_fail;
12167 }
12168 {
12169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12170 }
12171 return resultobj;
12172 fail:
12173 return NULL;
12174 }
12175
12176
12177 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
12178 PyObject *resultobj = NULL;
12179 wxImage *arg1 = (wxImage *) 0 ;
12180 byte *arg2 = (byte *) 0 ;
12181 byte *arg3 = (byte *) 0 ;
12182 byte *arg4 = (byte *) 0 ;
12183 byte arg5 = (byte) 0 ;
12184 byte arg6 = (byte) 0 ;
12185 byte arg7 = (byte) 0 ;
12186 bool result;
12187 byte temp2 ;
12188 int res2 = 0 ;
12189 byte temp3 ;
12190 int res3 = 0 ;
12191 byte temp4 ;
12192 int res4 = 0 ;
12193 PyObject * obj0 = 0 ;
12194 PyObject * obj1 = 0 ;
12195 PyObject * obj2 = 0 ;
12196 PyObject * obj3 = 0 ;
12197 char *kwnames[] = {
12198 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12199 };
12200
12201 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12202 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12203 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12206 if (SWIG_arg_fail(1)) SWIG_fail;
12207 if (obj1) {
12208 {
12209 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12210 if (SWIG_arg_fail(5)) SWIG_fail;
12211 }
12212 }
12213 if (obj2) {
12214 {
12215 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12216 if (SWIG_arg_fail(6)) SWIG_fail;
12217 }
12218 }
12219 if (obj3) {
12220 {
12221 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12222 if (SWIG_arg_fail(7)) SWIG_fail;
12223 }
12224 }
12225 {
12226 PyThreadState* __tstate = wxPyBeginAllowThreads();
12227 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12228
12229 wxPyEndAllowThreads(__tstate);
12230 if (PyErr_Occurred()) SWIG_fail;
12231 }
12232 {
12233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12234 }
12235 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12236 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12237 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12238 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12239 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12240 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12241 return resultobj;
12242 fail:
12243 return NULL;
12244 }
12245
12246
12247 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
12248 PyObject *resultobj = NULL;
12249 wxImage *arg1 = (wxImage *) 0 ;
12250 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12251 bool result;
12252 PyObject * obj0 = 0 ;
12253 PyObject * obj1 = 0 ;
12254 char *kwnames[] = {
12255 (char *) "self",(char *) "threshold", NULL
12256 };
12257
12258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
12259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12260 if (SWIG_arg_fail(1)) SWIG_fail;
12261 if (obj1) {
12262 {
12263 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12264 if (SWIG_arg_fail(2)) SWIG_fail;
12265 }
12266 }
12267 {
12268 PyThreadState* __tstate = wxPyBeginAllowThreads();
12269 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
12270
12271 wxPyEndAllowThreads(__tstate);
12272 if (PyErr_Occurred()) SWIG_fail;
12273 }
12274 {
12275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12276 }
12277 return resultobj;
12278 fail:
12279 return NULL;
12280 }
12281
12282
12283 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12284 PyObject *resultobj = NULL;
12285 wxImage *arg1 = (wxImage *) 0 ;
12286 byte arg2 ;
12287 byte arg3 ;
12288 byte arg4 ;
12289 bool result;
12290 PyObject * obj0 = 0 ;
12291 PyObject * obj1 = 0 ;
12292 PyObject * obj2 = 0 ;
12293 PyObject * obj3 = 0 ;
12294 char *kwnames[] = {
12295 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12296 };
12297
12298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12300 if (SWIG_arg_fail(1)) SWIG_fail;
12301 {
12302 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
12303 if (SWIG_arg_fail(2)) SWIG_fail;
12304 }
12305 {
12306 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12307 if (SWIG_arg_fail(3)) SWIG_fail;
12308 }
12309 {
12310 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12311 if (SWIG_arg_fail(4)) SWIG_fail;
12312 }
12313 {
12314 PyThreadState* __tstate = wxPyBeginAllowThreads();
12315 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
12316
12317 wxPyEndAllowThreads(__tstate);
12318 if (PyErr_Occurred()) SWIG_fail;
12319 }
12320 {
12321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12322 }
12323 return resultobj;
12324 fail:
12325 return NULL;
12326 }
12327
12328
12329 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
12330 PyObject *resultobj = NULL;
12331 wxImage *arg1 = (wxImage *) 0 ;
12332 wxImage *arg2 = 0 ;
12333 byte arg3 ;
12334 byte arg4 ;
12335 byte arg5 ;
12336 bool result;
12337 PyObject * obj0 = 0 ;
12338 PyObject * obj1 = 0 ;
12339 PyObject * obj2 = 0 ;
12340 PyObject * obj3 = 0 ;
12341 PyObject * obj4 = 0 ;
12342 char *kwnames[] = {
12343 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
12344 };
12345
12346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12348 if (SWIG_arg_fail(1)) SWIG_fail;
12349 {
12350 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12351 if (SWIG_arg_fail(2)) SWIG_fail;
12352 if (arg2 == NULL) {
12353 SWIG_null_ref("wxImage");
12354 }
12355 if (SWIG_arg_fail(2)) SWIG_fail;
12356 }
12357 {
12358 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
12359 if (SWIG_arg_fail(3)) SWIG_fail;
12360 }
12361 {
12362 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
12363 if (SWIG_arg_fail(4)) SWIG_fail;
12364 }
12365 {
12366 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
12367 if (SWIG_arg_fail(5)) SWIG_fail;
12368 }
12369 {
12370 PyThreadState* __tstate = wxPyBeginAllowThreads();
12371 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
12372
12373 wxPyEndAllowThreads(__tstate);
12374 if (PyErr_Occurred()) SWIG_fail;
12375 }
12376 {
12377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12378 }
12379 return resultobj;
12380 fail:
12381 return NULL;
12382 }
12383
12384
12385 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
12386 PyObject *resultobj = NULL;
12387 wxString *arg1 = 0 ;
12388 bool result;
12389 bool temp1 = false ;
12390 PyObject * obj0 = 0 ;
12391 char *kwnames[] = {
12392 (char *) "filename", NULL
12393 };
12394
12395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
12396 {
12397 arg1 = wxString_in_helper(obj0);
12398 if (arg1 == NULL) SWIG_fail;
12399 temp1 = true;
12400 }
12401 {
12402 PyThreadState* __tstate = wxPyBeginAllowThreads();
12403 result = (bool)wxImage::CanRead((wxString const &)*arg1);
12404
12405 wxPyEndAllowThreads(__tstate);
12406 if (PyErr_Occurred()) SWIG_fail;
12407 }
12408 {
12409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12410 }
12411 {
12412 if (temp1)
12413 delete arg1;
12414 }
12415 return resultobj;
12416 fail:
12417 {
12418 if (temp1)
12419 delete arg1;
12420 }
12421 return NULL;
12422 }
12423
12424
12425 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
12426 PyObject *resultobj = NULL;
12427 wxString *arg1 = 0 ;
12428 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12429 int result;
12430 bool temp1 = false ;
12431 PyObject * obj0 = 0 ;
12432 PyObject * obj1 = 0 ;
12433 char *kwnames[] = {
12434 (char *) "filename",(char *) "type", NULL
12435 };
12436
12437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
12438 {
12439 arg1 = wxString_in_helper(obj0);
12440 if (arg1 == NULL) SWIG_fail;
12441 temp1 = true;
12442 }
12443 if (obj1) {
12444 {
12445 arg2 = static_cast<long >(SWIG_As_long(obj1));
12446 if (SWIG_arg_fail(2)) SWIG_fail;
12447 }
12448 }
12449 {
12450 PyThreadState* __tstate = wxPyBeginAllowThreads();
12451 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
12452
12453 wxPyEndAllowThreads(__tstate);
12454 if (PyErr_Occurred()) SWIG_fail;
12455 }
12456 {
12457 resultobj = SWIG_From_int(static_cast<int >(result));
12458 }
12459 {
12460 if (temp1)
12461 delete arg1;
12462 }
12463 return resultobj;
12464 fail:
12465 {
12466 if (temp1)
12467 delete arg1;
12468 }
12469 return NULL;
12470 }
12471
12472
12473 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
12474 PyObject *resultobj = NULL;
12475 wxImage *arg1 = (wxImage *) 0 ;
12476 wxString *arg2 = 0 ;
12477 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12478 int arg4 = (int) -1 ;
12479 bool result;
12480 bool temp2 = false ;
12481 PyObject * obj0 = 0 ;
12482 PyObject * obj1 = 0 ;
12483 PyObject * obj2 = 0 ;
12484 PyObject * obj3 = 0 ;
12485 char *kwnames[] = {
12486 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
12487 };
12488
12489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12491 if (SWIG_arg_fail(1)) SWIG_fail;
12492 {
12493 arg2 = wxString_in_helper(obj1);
12494 if (arg2 == NULL) SWIG_fail;
12495 temp2 = true;
12496 }
12497 if (obj2) {
12498 {
12499 arg3 = static_cast<long >(SWIG_As_long(obj2));
12500 if (SWIG_arg_fail(3)) SWIG_fail;
12501 }
12502 }
12503 if (obj3) {
12504 {
12505 arg4 = static_cast<int >(SWIG_As_int(obj3));
12506 if (SWIG_arg_fail(4)) SWIG_fail;
12507 }
12508 }
12509 {
12510 PyThreadState* __tstate = wxPyBeginAllowThreads();
12511 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
12512
12513 wxPyEndAllowThreads(__tstate);
12514 if (PyErr_Occurred()) SWIG_fail;
12515 }
12516 {
12517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12518 }
12519 {
12520 if (temp2)
12521 delete arg2;
12522 }
12523 return resultobj;
12524 fail:
12525 {
12526 if (temp2)
12527 delete arg2;
12528 }
12529 return NULL;
12530 }
12531
12532
12533 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12534 PyObject *resultobj = NULL;
12535 wxImage *arg1 = (wxImage *) 0 ;
12536 wxString *arg2 = 0 ;
12537 wxString *arg3 = 0 ;
12538 int arg4 = (int) -1 ;
12539 bool result;
12540 bool temp2 = false ;
12541 bool temp3 = false ;
12542 PyObject * obj0 = 0 ;
12543 PyObject * obj1 = 0 ;
12544 PyObject * obj2 = 0 ;
12545 PyObject * obj3 = 0 ;
12546 char *kwnames[] = {
12547 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
12548 };
12549
12550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12552 if (SWIG_arg_fail(1)) SWIG_fail;
12553 {
12554 arg2 = wxString_in_helper(obj1);
12555 if (arg2 == NULL) SWIG_fail;
12556 temp2 = true;
12557 }
12558 {
12559 arg3 = wxString_in_helper(obj2);
12560 if (arg3 == NULL) SWIG_fail;
12561 temp3 = true;
12562 }
12563 if (obj3) {
12564 {
12565 arg4 = static_cast<int >(SWIG_As_int(obj3));
12566 if (SWIG_arg_fail(4)) SWIG_fail;
12567 }
12568 }
12569 {
12570 PyThreadState* __tstate = wxPyBeginAllowThreads();
12571 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
12572
12573 wxPyEndAllowThreads(__tstate);
12574 if (PyErr_Occurred()) SWIG_fail;
12575 }
12576 {
12577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12578 }
12579 {
12580 if (temp2)
12581 delete arg2;
12582 }
12583 {
12584 if (temp3)
12585 delete arg3;
12586 }
12587 return resultobj;
12588 fail:
12589 {
12590 if (temp2)
12591 delete arg2;
12592 }
12593 {
12594 if (temp3)
12595 delete arg3;
12596 }
12597 return NULL;
12598 }
12599
12600
12601 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12602 PyObject *resultobj = NULL;
12603 wxImage *arg1 = (wxImage *) 0 ;
12604 wxString *arg2 = 0 ;
12605 int arg3 ;
12606 bool result;
12607 bool temp2 = false ;
12608 PyObject * obj0 = 0 ;
12609 PyObject * obj1 = 0 ;
12610 PyObject * obj2 = 0 ;
12611 char *kwnames[] = {
12612 (char *) "self",(char *) "name",(char *) "type", NULL
12613 };
12614
12615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12617 if (SWIG_arg_fail(1)) SWIG_fail;
12618 {
12619 arg2 = wxString_in_helper(obj1);
12620 if (arg2 == NULL) SWIG_fail;
12621 temp2 = true;
12622 }
12623 {
12624 arg3 = static_cast<int >(SWIG_As_int(obj2));
12625 if (SWIG_arg_fail(3)) SWIG_fail;
12626 }
12627 {
12628 PyThreadState* __tstate = wxPyBeginAllowThreads();
12629 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12630
12631 wxPyEndAllowThreads(__tstate);
12632 if (PyErr_Occurred()) SWIG_fail;
12633 }
12634 {
12635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12636 }
12637 {
12638 if (temp2)
12639 delete arg2;
12640 }
12641 return resultobj;
12642 fail:
12643 {
12644 if (temp2)
12645 delete arg2;
12646 }
12647 return NULL;
12648 }
12649
12650
12651 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12652 PyObject *resultobj = NULL;
12653 wxImage *arg1 = (wxImage *) 0 ;
12654 wxString *arg2 = 0 ;
12655 wxString *arg3 = 0 ;
12656 bool result;
12657 bool temp2 = false ;
12658 bool temp3 = false ;
12659 PyObject * obj0 = 0 ;
12660 PyObject * obj1 = 0 ;
12661 PyObject * obj2 = 0 ;
12662 char *kwnames[] = {
12663 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12664 };
12665
12666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12668 if (SWIG_arg_fail(1)) SWIG_fail;
12669 {
12670 arg2 = wxString_in_helper(obj1);
12671 if (arg2 == NULL) SWIG_fail;
12672 temp2 = true;
12673 }
12674 {
12675 arg3 = wxString_in_helper(obj2);
12676 if (arg3 == NULL) SWIG_fail;
12677 temp3 = true;
12678 }
12679 {
12680 PyThreadState* __tstate = wxPyBeginAllowThreads();
12681 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12682
12683 wxPyEndAllowThreads(__tstate);
12684 if (PyErr_Occurred()) SWIG_fail;
12685 }
12686 {
12687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12688 }
12689 {
12690 if (temp2)
12691 delete arg2;
12692 }
12693 {
12694 if (temp3)
12695 delete arg3;
12696 }
12697 return resultobj;
12698 fail:
12699 {
12700 if (temp2)
12701 delete arg2;
12702 }
12703 {
12704 if (temp3)
12705 delete arg3;
12706 }
12707 return NULL;
12708 }
12709
12710
12711 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12712 PyObject *resultobj = NULL;
12713 wxInputStream *arg1 = 0 ;
12714 bool result;
12715 wxPyInputStream *temp1 ;
12716 bool created1 ;
12717 PyObject * obj0 = 0 ;
12718 char *kwnames[] = {
12719 (char *) "stream", NULL
12720 };
12721
12722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12723 {
12724 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12725 arg1 = temp1->m_wxis;
12726 created1 = false;
12727 } else {
12728 PyErr_Clear(); // clear the failure of the wxPyConvert above
12729 arg1 = wxPyCBInputStream_create(obj0, false);
12730 if (arg1 == NULL) {
12731 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12732 SWIG_fail;
12733 }
12734 created1 = true;
12735 }
12736 }
12737 {
12738 PyThreadState* __tstate = wxPyBeginAllowThreads();
12739 result = (bool)wxImage::CanRead(*arg1);
12740
12741 wxPyEndAllowThreads(__tstate);
12742 if (PyErr_Occurred()) SWIG_fail;
12743 }
12744 {
12745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12746 }
12747 {
12748 if (created1) delete arg1;
12749 }
12750 return resultobj;
12751 fail:
12752 {
12753 if (created1) delete arg1;
12754 }
12755 return NULL;
12756 }
12757
12758
12759 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12760 PyObject *resultobj = NULL;
12761 wxImage *arg1 = (wxImage *) 0 ;
12762 wxInputStream *arg2 = 0 ;
12763 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12764 int arg4 = (int) -1 ;
12765 bool result;
12766 wxPyInputStream *temp2 ;
12767 bool created2 ;
12768 PyObject * obj0 = 0 ;
12769 PyObject * obj1 = 0 ;
12770 PyObject * obj2 = 0 ;
12771 PyObject * obj3 = 0 ;
12772 char *kwnames[] = {
12773 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12774 };
12775
12776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12778 if (SWIG_arg_fail(1)) SWIG_fail;
12779 {
12780 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12781 arg2 = temp2->m_wxis;
12782 created2 = false;
12783 } else {
12784 PyErr_Clear(); // clear the failure of the wxPyConvert above
12785 arg2 = wxPyCBInputStream_create(obj1, false);
12786 if (arg2 == NULL) {
12787 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12788 SWIG_fail;
12789 }
12790 created2 = true;
12791 }
12792 }
12793 if (obj2) {
12794 {
12795 arg3 = static_cast<long >(SWIG_As_long(obj2));
12796 if (SWIG_arg_fail(3)) SWIG_fail;
12797 }
12798 }
12799 if (obj3) {
12800 {
12801 arg4 = static_cast<int >(SWIG_As_int(obj3));
12802 if (SWIG_arg_fail(4)) SWIG_fail;
12803 }
12804 }
12805 {
12806 PyThreadState* __tstate = wxPyBeginAllowThreads();
12807 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12808
12809 wxPyEndAllowThreads(__tstate);
12810 if (PyErr_Occurred()) SWIG_fail;
12811 }
12812 {
12813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12814 }
12815 {
12816 if (created2) delete arg2;
12817 }
12818 return resultobj;
12819 fail:
12820 {
12821 if (created2) delete arg2;
12822 }
12823 return NULL;
12824 }
12825
12826
12827 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12828 PyObject *resultobj = NULL;
12829 wxImage *arg1 = (wxImage *) 0 ;
12830 wxInputStream *arg2 = 0 ;
12831 wxString *arg3 = 0 ;
12832 int arg4 = (int) -1 ;
12833 bool result;
12834 wxPyInputStream *temp2 ;
12835 bool created2 ;
12836 bool temp3 = false ;
12837 PyObject * obj0 = 0 ;
12838 PyObject * obj1 = 0 ;
12839 PyObject * obj2 = 0 ;
12840 PyObject * obj3 = 0 ;
12841 char *kwnames[] = {
12842 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12843 };
12844
12845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12847 if (SWIG_arg_fail(1)) SWIG_fail;
12848 {
12849 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12850 arg2 = temp2->m_wxis;
12851 created2 = false;
12852 } else {
12853 PyErr_Clear(); // clear the failure of the wxPyConvert above
12854 arg2 = wxPyCBInputStream_create(obj1, false);
12855 if (arg2 == NULL) {
12856 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12857 SWIG_fail;
12858 }
12859 created2 = true;
12860 }
12861 }
12862 {
12863 arg3 = wxString_in_helper(obj2);
12864 if (arg3 == NULL) SWIG_fail;
12865 temp3 = true;
12866 }
12867 if (obj3) {
12868 {
12869 arg4 = static_cast<int >(SWIG_As_int(obj3));
12870 if (SWIG_arg_fail(4)) SWIG_fail;
12871 }
12872 }
12873 {
12874 PyThreadState* __tstate = wxPyBeginAllowThreads();
12875 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12876
12877 wxPyEndAllowThreads(__tstate);
12878 if (PyErr_Occurred()) SWIG_fail;
12879 }
12880 {
12881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12882 }
12883 {
12884 if (created2) delete arg2;
12885 }
12886 {
12887 if (temp3)
12888 delete arg3;
12889 }
12890 return resultobj;
12891 fail:
12892 {
12893 if (created2) delete arg2;
12894 }
12895 {
12896 if (temp3)
12897 delete arg3;
12898 }
12899 return NULL;
12900 }
12901
12902
12903 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12904 PyObject *resultobj = NULL;
12905 wxImage *arg1 = (wxImage *) 0 ;
12906 bool result;
12907 PyObject * obj0 = 0 ;
12908 char *kwnames[] = {
12909 (char *) "self", NULL
12910 };
12911
12912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12914 if (SWIG_arg_fail(1)) SWIG_fail;
12915 {
12916 PyThreadState* __tstate = wxPyBeginAllowThreads();
12917 result = (bool)(arg1)->Ok();
12918
12919 wxPyEndAllowThreads(__tstate);
12920 if (PyErr_Occurred()) SWIG_fail;
12921 }
12922 {
12923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12924 }
12925 return resultobj;
12926 fail:
12927 return NULL;
12928 }
12929
12930
12931 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12932 PyObject *resultobj = NULL;
12933 wxImage *arg1 = (wxImage *) 0 ;
12934 int result;
12935 PyObject * obj0 = 0 ;
12936 char *kwnames[] = {
12937 (char *) "self", NULL
12938 };
12939
12940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12942 if (SWIG_arg_fail(1)) SWIG_fail;
12943 {
12944 PyThreadState* __tstate = wxPyBeginAllowThreads();
12945 result = (int)(arg1)->GetWidth();
12946
12947 wxPyEndAllowThreads(__tstate);
12948 if (PyErr_Occurred()) SWIG_fail;
12949 }
12950 {
12951 resultobj = SWIG_From_int(static_cast<int >(result));
12952 }
12953 return resultobj;
12954 fail:
12955 return NULL;
12956 }
12957
12958
12959 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12960 PyObject *resultobj = NULL;
12961 wxImage *arg1 = (wxImage *) 0 ;
12962 int result;
12963 PyObject * obj0 = 0 ;
12964 char *kwnames[] = {
12965 (char *) "self", NULL
12966 };
12967
12968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12970 if (SWIG_arg_fail(1)) SWIG_fail;
12971 {
12972 PyThreadState* __tstate = wxPyBeginAllowThreads();
12973 result = (int)(arg1)->GetHeight();
12974
12975 wxPyEndAllowThreads(__tstate);
12976 if (PyErr_Occurred()) SWIG_fail;
12977 }
12978 {
12979 resultobj = SWIG_From_int(static_cast<int >(result));
12980 }
12981 return resultobj;
12982 fail:
12983 return NULL;
12984 }
12985
12986
12987 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12988 PyObject *resultobj = NULL;
12989 wxImage *arg1 = (wxImage *) 0 ;
12990 wxSize result;
12991 PyObject * obj0 = 0 ;
12992 char *kwnames[] = {
12993 (char *) "self", NULL
12994 };
12995
12996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12998 if (SWIG_arg_fail(1)) SWIG_fail;
12999 {
13000 PyThreadState* __tstate = wxPyBeginAllowThreads();
13001 result = wxImage_GetSize(arg1);
13002
13003 wxPyEndAllowThreads(__tstate);
13004 if (PyErr_Occurred()) SWIG_fail;
13005 }
13006 {
13007 wxSize * resultptr;
13008 resultptr = new wxSize(static_cast<wxSize & >(result));
13009 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
13010 }
13011 return resultobj;
13012 fail:
13013 return NULL;
13014 }
13015
13016
13017 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
13018 PyObject *resultobj = NULL;
13019 wxImage *arg1 = (wxImage *) 0 ;
13020 wxRect *arg2 = 0 ;
13021 SwigValueWrapper<wxImage > result;
13022 wxRect temp2 ;
13023 PyObject * obj0 = 0 ;
13024 PyObject * obj1 = 0 ;
13025 char *kwnames[] = {
13026 (char *) "self",(char *) "rect", NULL
13027 };
13028
13029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
13030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13031 if (SWIG_arg_fail(1)) SWIG_fail;
13032 {
13033 arg2 = &temp2;
13034 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13035 }
13036 {
13037 PyThreadState* __tstate = wxPyBeginAllowThreads();
13038 result = (arg1)->GetSubImage((wxRect const &)*arg2);
13039
13040 wxPyEndAllowThreads(__tstate);
13041 if (PyErr_Occurred()) SWIG_fail;
13042 }
13043 {
13044 wxImage * resultptr;
13045 resultptr = new wxImage(static_cast<wxImage & >(result));
13046 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13047 }
13048 return resultobj;
13049 fail:
13050 return NULL;
13051 }
13052
13053
13054 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
13055 PyObject *resultobj = NULL;
13056 wxImage *arg1 = (wxImage *) 0 ;
13057 wxSize *arg2 = 0 ;
13058 wxPoint *arg3 = 0 ;
13059 int arg4 = (int) -1 ;
13060 int arg5 = (int) -1 ;
13061 int arg6 = (int) -1 ;
13062 SwigValueWrapper<wxImage > result;
13063 wxSize temp2 ;
13064 wxPoint temp3 ;
13065 PyObject * obj0 = 0 ;
13066 PyObject * obj1 = 0 ;
13067 PyObject * obj2 = 0 ;
13068 PyObject * obj3 = 0 ;
13069 PyObject * obj4 = 0 ;
13070 PyObject * obj5 = 0 ;
13071 char *kwnames[] = {
13072 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13073 };
13074
13075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
13076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13077 if (SWIG_arg_fail(1)) SWIG_fail;
13078 {
13079 arg2 = &temp2;
13080 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13081 }
13082 {
13083 arg3 = &temp3;
13084 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13085 }
13086 if (obj3) {
13087 {
13088 arg4 = static_cast<int >(SWIG_As_int(obj3));
13089 if (SWIG_arg_fail(4)) SWIG_fail;
13090 }
13091 }
13092 if (obj4) {
13093 {
13094 arg5 = static_cast<int >(SWIG_As_int(obj4));
13095 if (SWIG_arg_fail(5)) SWIG_fail;
13096 }
13097 }
13098 if (obj5) {
13099 {
13100 arg6 = static_cast<int >(SWIG_As_int(obj5));
13101 if (SWIG_arg_fail(6)) SWIG_fail;
13102 }
13103 }
13104 {
13105 PyThreadState* __tstate = wxPyBeginAllowThreads();
13106 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13107
13108 wxPyEndAllowThreads(__tstate);
13109 if (PyErr_Occurred()) SWIG_fail;
13110 }
13111 {
13112 wxImage * resultptr;
13113 resultptr = new wxImage(static_cast<wxImage & >(result));
13114 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13115 }
13116 return resultobj;
13117 fail:
13118 return NULL;
13119 }
13120
13121
13122 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
13123 PyObject *resultobj = NULL;
13124 wxImage *arg1 = (wxImage *) 0 ;
13125 SwigValueWrapper<wxImage > result;
13126 PyObject * obj0 = 0 ;
13127 char *kwnames[] = {
13128 (char *) "self", NULL
13129 };
13130
13131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
13132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13133 if (SWIG_arg_fail(1)) SWIG_fail;
13134 {
13135 PyThreadState* __tstate = wxPyBeginAllowThreads();
13136 result = (arg1)->Copy();
13137
13138 wxPyEndAllowThreads(__tstate);
13139 if (PyErr_Occurred()) SWIG_fail;
13140 }
13141 {
13142 wxImage * resultptr;
13143 resultptr = new wxImage(static_cast<wxImage & >(result));
13144 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13145 }
13146 return resultobj;
13147 fail:
13148 return NULL;
13149 }
13150
13151
13152 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
13153 PyObject *resultobj = NULL;
13154 wxImage *arg1 = (wxImage *) 0 ;
13155 wxImage *arg2 = 0 ;
13156 int arg3 ;
13157 int arg4 ;
13158 PyObject * obj0 = 0 ;
13159 PyObject * obj1 = 0 ;
13160 PyObject * obj2 = 0 ;
13161 PyObject * obj3 = 0 ;
13162 char *kwnames[] = {
13163 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
13164 };
13165
13166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13168 if (SWIG_arg_fail(1)) SWIG_fail;
13169 {
13170 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13171 if (SWIG_arg_fail(2)) SWIG_fail;
13172 if (arg2 == NULL) {
13173 SWIG_null_ref("wxImage");
13174 }
13175 if (SWIG_arg_fail(2)) SWIG_fail;
13176 }
13177 {
13178 arg3 = static_cast<int >(SWIG_As_int(obj2));
13179 if (SWIG_arg_fail(3)) SWIG_fail;
13180 }
13181 {
13182 arg4 = static_cast<int >(SWIG_As_int(obj3));
13183 if (SWIG_arg_fail(4)) SWIG_fail;
13184 }
13185 {
13186 PyThreadState* __tstate = wxPyBeginAllowThreads();
13187 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
13188
13189 wxPyEndAllowThreads(__tstate);
13190 if (PyErr_Occurred()) SWIG_fail;
13191 }
13192 Py_INCREF(Py_None); resultobj = Py_None;
13193 return resultobj;
13194 fail:
13195 return NULL;
13196 }
13197
13198
13199 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
13200 PyObject *resultobj = NULL;
13201 wxImage *arg1 = (wxImage *) 0 ;
13202 PyObject *result;
13203 PyObject * obj0 = 0 ;
13204 char *kwnames[] = {
13205 (char *) "self", NULL
13206 };
13207
13208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
13209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13210 if (SWIG_arg_fail(1)) SWIG_fail;
13211 {
13212 PyThreadState* __tstate = wxPyBeginAllowThreads();
13213 result = (PyObject *)wxImage_GetData(arg1);
13214
13215 wxPyEndAllowThreads(__tstate);
13216 if (PyErr_Occurred()) SWIG_fail;
13217 }
13218 resultobj = result;
13219 return resultobj;
13220 fail:
13221 return NULL;
13222 }
13223
13224
13225 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
13226 PyObject *resultobj = NULL;
13227 wxImage *arg1 = (wxImage *) 0 ;
13228 buffer arg2 ;
13229 int arg3 ;
13230 PyObject * obj0 = 0 ;
13231 PyObject * obj1 = 0 ;
13232 char *kwnames[] = {
13233 (char *) "self",(char *) "data", NULL
13234 };
13235
13236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
13237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13238 if (SWIG_arg_fail(1)) SWIG_fail;
13239 {
13240 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13241 }
13242 {
13243 PyThreadState* __tstate = wxPyBeginAllowThreads();
13244 wxImage_SetData(arg1,arg2,arg3);
13245
13246 wxPyEndAllowThreads(__tstate);
13247 if (PyErr_Occurred()) SWIG_fail;
13248 }
13249 Py_INCREF(Py_None); resultobj = Py_None;
13250 return resultobj;
13251 fail:
13252 return NULL;
13253 }
13254
13255
13256 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13257 PyObject *resultobj = NULL;
13258 wxImage *arg1 = (wxImage *) 0 ;
13259 PyObject *result;
13260 PyObject * obj0 = 0 ;
13261 char *kwnames[] = {
13262 (char *) "self", NULL
13263 };
13264
13265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
13266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13267 if (SWIG_arg_fail(1)) SWIG_fail;
13268 {
13269 PyThreadState* __tstate = wxPyBeginAllowThreads();
13270 result = (PyObject *)wxImage_GetDataBuffer(arg1);
13271
13272 wxPyEndAllowThreads(__tstate);
13273 if (PyErr_Occurred()) SWIG_fail;
13274 }
13275 resultobj = result;
13276 return resultobj;
13277 fail:
13278 return NULL;
13279 }
13280
13281
13282 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13283 PyObject *resultobj = NULL;
13284 wxImage *arg1 = (wxImage *) 0 ;
13285 buffer arg2 ;
13286 int arg3 ;
13287 PyObject * obj0 = 0 ;
13288 PyObject * obj1 = 0 ;
13289 char *kwnames[] = {
13290 (char *) "self",(char *) "data", NULL
13291 };
13292
13293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
13294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13295 if (SWIG_arg_fail(1)) SWIG_fail;
13296 {
13297 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13298 }
13299 {
13300 PyThreadState* __tstate = wxPyBeginAllowThreads();
13301 wxImage_SetDataBuffer(arg1,arg2,arg3);
13302
13303 wxPyEndAllowThreads(__tstate);
13304 if (PyErr_Occurred()) SWIG_fail;
13305 }
13306 Py_INCREF(Py_None); resultobj = Py_None;
13307 return resultobj;
13308 fail:
13309 return NULL;
13310 }
13311
13312
13313 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13314 PyObject *resultobj = NULL;
13315 wxImage *arg1 = (wxImage *) 0 ;
13316 PyObject *result;
13317 PyObject * obj0 = 0 ;
13318 char *kwnames[] = {
13319 (char *) "self", NULL
13320 };
13321
13322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
13323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13324 if (SWIG_arg_fail(1)) SWIG_fail;
13325 {
13326 PyThreadState* __tstate = wxPyBeginAllowThreads();
13327 result = (PyObject *)wxImage_GetAlphaData(arg1);
13328
13329 wxPyEndAllowThreads(__tstate);
13330 if (PyErr_Occurred()) SWIG_fail;
13331 }
13332 resultobj = result;
13333 return resultobj;
13334 fail:
13335 return NULL;
13336 }
13337
13338
13339 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13340 PyObject *resultobj = NULL;
13341 wxImage *arg1 = (wxImage *) 0 ;
13342 buffer arg2 ;
13343 int arg3 ;
13344 PyObject * obj0 = 0 ;
13345 PyObject * obj1 = 0 ;
13346 char *kwnames[] = {
13347 (char *) "self",(char *) "alpha", NULL
13348 };
13349
13350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
13351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13352 if (SWIG_arg_fail(1)) SWIG_fail;
13353 {
13354 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13355 }
13356 {
13357 PyThreadState* __tstate = wxPyBeginAllowThreads();
13358 wxImage_SetAlphaData(arg1,arg2,arg3);
13359
13360 wxPyEndAllowThreads(__tstate);
13361 if (PyErr_Occurred()) SWIG_fail;
13362 }
13363 Py_INCREF(Py_None); resultobj = Py_None;
13364 return resultobj;
13365 fail:
13366 return NULL;
13367 }
13368
13369
13370 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13371 PyObject *resultobj = NULL;
13372 wxImage *arg1 = (wxImage *) 0 ;
13373 PyObject *result;
13374 PyObject * obj0 = 0 ;
13375 char *kwnames[] = {
13376 (char *) "self", NULL
13377 };
13378
13379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
13380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13381 if (SWIG_arg_fail(1)) SWIG_fail;
13382 {
13383 PyThreadState* __tstate = wxPyBeginAllowThreads();
13384 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
13385
13386 wxPyEndAllowThreads(__tstate);
13387 if (PyErr_Occurred()) SWIG_fail;
13388 }
13389 resultobj = result;
13390 return resultobj;
13391 fail:
13392 return NULL;
13393 }
13394
13395
13396 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13397 PyObject *resultobj = NULL;
13398 wxImage *arg1 = (wxImage *) 0 ;
13399 buffer arg2 ;
13400 int arg3 ;
13401 PyObject * obj0 = 0 ;
13402 PyObject * obj1 = 0 ;
13403 char *kwnames[] = {
13404 (char *) "self",(char *) "alpha", NULL
13405 };
13406
13407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
13408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13409 if (SWIG_arg_fail(1)) SWIG_fail;
13410 {
13411 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13412 }
13413 {
13414 PyThreadState* __tstate = wxPyBeginAllowThreads();
13415 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
13416
13417 wxPyEndAllowThreads(__tstate);
13418 if (PyErr_Occurred()) SWIG_fail;
13419 }
13420 Py_INCREF(Py_None); resultobj = Py_None;
13421 return resultobj;
13422 fail:
13423 return NULL;
13424 }
13425
13426
13427 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13428 PyObject *resultobj = NULL;
13429 wxImage *arg1 = (wxImage *) 0 ;
13430 byte arg2 ;
13431 byte arg3 ;
13432 byte arg4 ;
13433 PyObject * obj0 = 0 ;
13434 PyObject * obj1 = 0 ;
13435 PyObject * obj2 = 0 ;
13436 PyObject * obj3 = 0 ;
13437 char *kwnames[] = {
13438 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13439 };
13440
13441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13443 if (SWIG_arg_fail(1)) SWIG_fail;
13444 {
13445 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13446 if (SWIG_arg_fail(2)) SWIG_fail;
13447 }
13448 {
13449 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13450 if (SWIG_arg_fail(3)) SWIG_fail;
13451 }
13452 {
13453 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13454 if (SWIG_arg_fail(4)) SWIG_fail;
13455 }
13456 {
13457 PyThreadState* __tstate = wxPyBeginAllowThreads();
13458 (arg1)->SetMaskColour(arg2,arg3,arg4);
13459
13460 wxPyEndAllowThreads(__tstate);
13461 if (PyErr_Occurred()) SWIG_fail;
13462 }
13463 Py_INCREF(Py_None); resultobj = Py_None;
13464 return resultobj;
13465 fail:
13466 return NULL;
13467 }
13468
13469
13470 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13471 PyObject *resultobj = NULL;
13472 wxImage *arg1 = (wxImage *) 0 ;
13473 byte *arg2 = (byte *) 0 ;
13474 byte *arg3 = (byte *) 0 ;
13475 byte *arg4 = (byte *) 0 ;
13476 byte temp2 ;
13477 int res2 = 0 ;
13478 byte temp3 ;
13479 int res3 = 0 ;
13480 byte temp4 ;
13481 int res4 = 0 ;
13482 PyObject * obj0 = 0 ;
13483 char *kwnames[] = {
13484 (char *) "self", NULL
13485 };
13486
13487 arg2 = &temp2; res2 = SWIG_NEWOBJ;
13488 arg3 = &temp3; res3 = SWIG_NEWOBJ;
13489 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
13491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13492 if (SWIG_arg_fail(1)) SWIG_fail;
13493 {
13494 PyThreadState* __tstate = wxPyBeginAllowThreads();
13495 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
13496
13497 wxPyEndAllowThreads(__tstate);
13498 if (PyErr_Occurred()) SWIG_fail;
13499 }
13500 Py_INCREF(Py_None); resultobj = Py_None;
13501 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
13502 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
13503 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
13504 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
13505 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13506 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
13507 return resultobj;
13508 fail:
13509 return NULL;
13510 }
13511
13512
13513 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
13514 PyObject *resultobj = NULL;
13515 wxImage *arg1 = (wxImage *) 0 ;
13516 byte result;
13517 PyObject * obj0 = 0 ;
13518 char *kwnames[] = {
13519 (char *) "self", NULL
13520 };
13521
13522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
13523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13524 if (SWIG_arg_fail(1)) SWIG_fail;
13525 {
13526 PyThreadState* __tstate = wxPyBeginAllowThreads();
13527 result = (byte)(arg1)->GetMaskRed();
13528
13529 wxPyEndAllowThreads(__tstate);
13530 if (PyErr_Occurred()) SWIG_fail;
13531 }
13532 {
13533 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13534 }
13535 return resultobj;
13536 fail:
13537 return NULL;
13538 }
13539
13540
13541 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
13542 PyObject *resultobj = NULL;
13543 wxImage *arg1 = (wxImage *) 0 ;
13544 byte result;
13545 PyObject * obj0 = 0 ;
13546 char *kwnames[] = {
13547 (char *) "self", NULL
13548 };
13549
13550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
13551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13552 if (SWIG_arg_fail(1)) SWIG_fail;
13553 {
13554 PyThreadState* __tstate = wxPyBeginAllowThreads();
13555 result = (byte)(arg1)->GetMaskGreen();
13556
13557 wxPyEndAllowThreads(__tstate);
13558 if (PyErr_Occurred()) SWIG_fail;
13559 }
13560 {
13561 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13562 }
13563 return resultobj;
13564 fail:
13565 return NULL;
13566 }
13567
13568
13569 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
13570 PyObject *resultobj = NULL;
13571 wxImage *arg1 = (wxImage *) 0 ;
13572 byte result;
13573 PyObject * obj0 = 0 ;
13574 char *kwnames[] = {
13575 (char *) "self", NULL
13576 };
13577
13578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
13579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13580 if (SWIG_arg_fail(1)) SWIG_fail;
13581 {
13582 PyThreadState* __tstate = wxPyBeginAllowThreads();
13583 result = (byte)(arg1)->GetMaskBlue();
13584
13585 wxPyEndAllowThreads(__tstate);
13586 if (PyErr_Occurred()) SWIG_fail;
13587 }
13588 {
13589 resultobj = SWIG_From_unsigned_SS_char(static_cast<unsigned char >(result));
13590 }
13591 return resultobj;
13592 fail:
13593 return NULL;
13594 }
13595
13596
13597 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
13598 PyObject *resultobj = NULL;
13599 wxImage *arg1 = (wxImage *) 0 ;
13600 bool arg2 = (bool) true ;
13601 PyObject * obj0 = 0 ;
13602 PyObject * obj1 = 0 ;
13603 char *kwnames[] = {
13604 (char *) "self",(char *) "mask", NULL
13605 };
13606
13607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13609 if (SWIG_arg_fail(1)) SWIG_fail;
13610 if (obj1) {
13611 {
13612 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13613 if (SWIG_arg_fail(2)) SWIG_fail;
13614 }
13615 }
13616 {
13617 PyThreadState* __tstate = wxPyBeginAllowThreads();
13618 (arg1)->SetMask(arg2);
13619
13620 wxPyEndAllowThreads(__tstate);
13621 if (PyErr_Occurred()) SWIG_fail;
13622 }
13623 Py_INCREF(Py_None); resultobj = Py_None;
13624 return resultobj;
13625 fail:
13626 return NULL;
13627 }
13628
13629
13630 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13631 PyObject *resultobj = NULL;
13632 wxImage *arg1 = (wxImage *) 0 ;
13633 bool result;
13634 PyObject * obj0 = 0 ;
13635 char *kwnames[] = {
13636 (char *) "self", NULL
13637 };
13638
13639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13641 if (SWIG_arg_fail(1)) SWIG_fail;
13642 {
13643 PyThreadState* __tstate = wxPyBeginAllowThreads();
13644 result = (bool)(arg1)->HasMask();
13645
13646 wxPyEndAllowThreads(__tstate);
13647 if (PyErr_Occurred()) SWIG_fail;
13648 }
13649 {
13650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13651 }
13652 return resultobj;
13653 fail:
13654 return NULL;
13655 }
13656
13657
13658 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13659 PyObject *resultobj = NULL;
13660 wxImage *arg1 = (wxImage *) 0 ;
13661 double arg2 ;
13662 wxPoint *arg3 = 0 ;
13663 bool arg4 = (bool) true ;
13664 wxPoint *arg5 = (wxPoint *) NULL ;
13665 SwigValueWrapper<wxImage > result;
13666 wxPoint temp3 ;
13667 PyObject * obj0 = 0 ;
13668 PyObject * obj1 = 0 ;
13669 PyObject * obj2 = 0 ;
13670 PyObject * obj3 = 0 ;
13671 PyObject * obj4 = 0 ;
13672 char *kwnames[] = {
13673 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13674 };
13675
13676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13678 if (SWIG_arg_fail(1)) SWIG_fail;
13679 {
13680 arg2 = static_cast<double >(SWIG_As_double(obj1));
13681 if (SWIG_arg_fail(2)) SWIG_fail;
13682 }
13683 {
13684 arg3 = &temp3;
13685 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13686 }
13687 if (obj3) {
13688 {
13689 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
13690 if (SWIG_arg_fail(4)) SWIG_fail;
13691 }
13692 }
13693 if (obj4) {
13694 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13695 if (SWIG_arg_fail(5)) SWIG_fail;
13696 }
13697 {
13698 PyThreadState* __tstate = wxPyBeginAllowThreads();
13699 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13700
13701 wxPyEndAllowThreads(__tstate);
13702 if (PyErr_Occurred()) SWIG_fail;
13703 }
13704 {
13705 wxImage * resultptr;
13706 resultptr = new wxImage(static_cast<wxImage & >(result));
13707 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13708 }
13709 return resultobj;
13710 fail:
13711 return NULL;
13712 }
13713
13714
13715 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13716 PyObject *resultobj = NULL;
13717 wxImage *arg1 = (wxImage *) 0 ;
13718 bool arg2 = (bool) true ;
13719 SwigValueWrapper<wxImage > result;
13720 PyObject * obj0 = 0 ;
13721 PyObject * obj1 = 0 ;
13722 char *kwnames[] = {
13723 (char *) "self",(char *) "clockwise", NULL
13724 };
13725
13726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13728 if (SWIG_arg_fail(1)) SWIG_fail;
13729 if (obj1) {
13730 {
13731 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13732 if (SWIG_arg_fail(2)) SWIG_fail;
13733 }
13734 }
13735 {
13736 PyThreadState* __tstate = wxPyBeginAllowThreads();
13737 result = (arg1)->Rotate90(arg2);
13738
13739 wxPyEndAllowThreads(__tstate);
13740 if (PyErr_Occurred()) SWIG_fail;
13741 }
13742 {
13743 wxImage * resultptr;
13744 resultptr = new wxImage(static_cast<wxImage & >(result));
13745 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13746 }
13747 return resultobj;
13748 fail:
13749 return NULL;
13750 }
13751
13752
13753 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13754 PyObject *resultobj = NULL;
13755 wxImage *arg1 = (wxImage *) 0 ;
13756 bool arg2 = (bool) true ;
13757 SwigValueWrapper<wxImage > result;
13758 PyObject * obj0 = 0 ;
13759 PyObject * obj1 = 0 ;
13760 char *kwnames[] = {
13761 (char *) "self",(char *) "horizontally", NULL
13762 };
13763
13764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13766 if (SWIG_arg_fail(1)) SWIG_fail;
13767 if (obj1) {
13768 {
13769 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
13770 if (SWIG_arg_fail(2)) SWIG_fail;
13771 }
13772 }
13773 {
13774 PyThreadState* __tstate = wxPyBeginAllowThreads();
13775 result = (arg1)->Mirror(arg2);
13776
13777 wxPyEndAllowThreads(__tstate);
13778 if (PyErr_Occurred()) SWIG_fail;
13779 }
13780 {
13781 wxImage * resultptr;
13782 resultptr = new wxImage(static_cast<wxImage & >(result));
13783 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13784 }
13785 return resultobj;
13786 fail:
13787 return NULL;
13788 }
13789
13790
13791 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13792 PyObject *resultobj = NULL;
13793 wxImage *arg1 = (wxImage *) 0 ;
13794 byte arg2 ;
13795 byte arg3 ;
13796 byte arg4 ;
13797 byte arg5 ;
13798 byte arg6 ;
13799 byte arg7 ;
13800 PyObject * obj0 = 0 ;
13801 PyObject * obj1 = 0 ;
13802 PyObject * obj2 = 0 ;
13803 PyObject * obj3 = 0 ;
13804 PyObject * obj4 = 0 ;
13805 PyObject * obj5 = 0 ;
13806 PyObject * obj6 = 0 ;
13807 char *kwnames[] = {
13808 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13809 };
13810
13811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13813 if (SWIG_arg_fail(1)) SWIG_fail;
13814 {
13815 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13816 if (SWIG_arg_fail(2)) SWIG_fail;
13817 }
13818 {
13819 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13820 if (SWIG_arg_fail(3)) SWIG_fail;
13821 }
13822 {
13823 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13824 if (SWIG_arg_fail(4)) SWIG_fail;
13825 }
13826 {
13827 arg5 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj4));
13828 if (SWIG_arg_fail(5)) SWIG_fail;
13829 }
13830 {
13831 arg6 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj5));
13832 if (SWIG_arg_fail(6)) SWIG_fail;
13833 }
13834 {
13835 arg7 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj6));
13836 if (SWIG_arg_fail(7)) SWIG_fail;
13837 }
13838 {
13839 PyThreadState* __tstate = wxPyBeginAllowThreads();
13840 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13841
13842 wxPyEndAllowThreads(__tstate);
13843 if (PyErr_Occurred()) SWIG_fail;
13844 }
13845 Py_INCREF(Py_None); resultobj = Py_None;
13846 return resultobj;
13847 fail:
13848 return NULL;
13849 }
13850
13851
13852 static PyObject *_wrap_Image_ConvertToGreyscale(PyObject *, PyObject *args, PyObject *kwargs) {
13853 PyObject *resultobj = NULL;
13854 wxImage *arg1 = (wxImage *) 0 ;
13855 double arg2 = (double) 0.299 ;
13856 double arg3 = (double) 0.587 ;
13857 double arg4 = (double) 0.114 ;
13858 SwigValueWrapper<wxImage > result;
13859 PyObject * obj0 = 0 ;
13860 PyObject * obj1 = 0 ;
13861 PyObject * obj2 = 0 ;
13862 PyObject * obj3 = 0 ;
13863 char *kwnames[] = {
13864 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
13865 };
13866
13867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13869 if (SWIG_arg_fail(1)) SWIG_fail;
13870 if (obj1) {
13871 {
13872 arg2 = static_cast<double >(SWIG_As_double(obj1));
13873 if (SWIG_arg_fail(2)) SWIG_fail;
13874 }
13875 }
13876 if (obj2) {
13877 {
13878 arg3 = static_cast<double >(SWIG_As_double(obj2));
13879 if (SWIG_arg_fail(3)) SWIG_fail;
13880 }
13881 }
13882 if (obj3) {
13883 {
13884 arg4 = static_cast<double >(SWIG_As_double(obj3));
13885 if (SWIG_arg_fail(4)) SWIG_fail;
13886 }
13887 }
13888 {
13889 PyThreadState* __tstate = wxPyBeginAllowThreads();
13890 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
13891
13892 wxPyEndAllowThreads(__tstate);
13893 if (PyErr_Occurred()) SWIG_fail;
13894 }
13895 {
13896 wxImage * resultptr;
13897 resultptr = new wxImage(static_cast<wxImage & >(result));
13898 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13899 }
13900 return resultobj;
13901 fail:
13902 return NULL;
13903 }
13904
13905
13906 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13907 PyObject *resultobj = NULL;
13908 wxImage *arg1 = (wxImage *) 0 ;
13909 byte arg2 ;
13910 byte arg3 ;
13911 byte arg4 ;
13912 SwigValueWrapper<wxImage > result;
13913 PyObject * obj0 = 0 ;
13914 PyObject * obj1 = 0 ;
13915 PyObject * obj2 = 0 ;
13916 PyObject * obj3 = 0 ;
13917 char *kwnames[] = {
13918 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13919 };
13920
13921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13923 if (SWIG_arg_fail(1)) SWIG_fail;
13924 {
13925 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
13926 if (SWIG_arg_fail(2)) SWIG_fail;
13927 }
13928 {
13929 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
13930 if (SWIG_arg_fail(3)) SWIG_fail;
13931 }
13932 {
13933 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
13934 if (SWIG_arg_fail(4)) SWIG_fail;
13935 }
13936 {
13937 PyThreadState* __tstate = wxPyBeginAllowThreads();
13938 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13939
13940 wxPyEndAllowThreads(__tstate);
13941 if (PyErr_Occurred()) SWIG_fail;
13942 }
13943 {
13944 wxImage * resultptr;
13945 resultptr = new wxImage(static_cast<wxImage & >(result));
13946 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13947 }
13948 return resultobj;
13949 fail:
13950 return NULL;
13951 }
13952
13953
13954 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13955 PyObject *resultobj = NULL;
13956 wxImage *arg1 = (wxImage *) 0 ;
13957 wxString *arg2 = 0 ;
13958 wxString *arg3 = 0 ;
13959 bool temp2 = false ;
13960 bool temp3 = false ;
13961 PyObject * obj0 = 0 ;
13962 PyObject * obj1 = 0 ;
13963 PyObject * obj2 = 0 ;
13964 char *kwnames[] = {
13965 (char *) "self",(char *) "name",(char *) "value", NULL
13966 };
13967
13968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13970 if (SWIG_arg_fail(1)) SWIG_fail;
13971 {
13972 arg2 = wxString_in_helper(obj1);
13973 if (arg2 == NULL) SWIG_fail;
13974 temp2 = true;
13975 }
13976 {
13977 arg3 = wxString_in_helper(obj2);
13978 if (arg3 == NULL) SWIG_fail;
13979 temp3 = true;
13980 }
13981 {
13982 PyThreadState* __tstate = wxPyBeginAllowThreads();
13983 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13984
13985 wxPyEndAllowThreads(__tstate);
13986 if (PyErr_Occurred()) SWIG_fail;
13987 }
13988 Py_INCREF(Py_None); resultobj = Py_None;
13989 {
13990 if (temp2)
13991 delete arg2;
13992 }
13993 {
13994 if (temp3)
13995 delete arg3;
13996 }
13997 return resultobj;
13998 fail:
13999 {
14000 if (temp2)
14001 delete arg2;
14002 }
14003 {
14004 if (temp3)
14005 delete arg3;
14006 }
14007 return NULL;
14008 }
14009
14010
14011 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
14012 PyObject *resultobj = NULL;
14013 wxImage *arg1 = (wxImage *) 0 ;
14014 wxString *arg2 = 0 ;
14015 int arg3 ;
14016 bool temp2 = false ;
14017 PyObject * obj0 = 0 ;
14018 PyObject * obj1 = 0 ;
14019 PyObject * obj2 = 0 ;
14020 char *kwnames[] = {
14021 (char *) "self",(char *) "name",(char *) "value", NULL
14022 };
14023
14024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
14025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14026 if (SWIG_arg_fail(1)) SWIG_fail;
14027 {
14028 arg2 = wxString_in_helper(obj1);
14029 if (arg2 == NULL) SWIG_fail;
14030 temp2 = true;
14031 }
14032 {
14033 arg3 = static_cast<int >(SWIG_As_int(obj2));
14034 if (SWIG_arg_fail(3)) SWIG_fail;
14035 }
14036 {
14037 PyThreadState* __tstate = wxPyBeginAllowThreads();
14038 (arg1)->SetOption((wxString const &)*arg2,arg3);
14039
14040 wxPyEndAllowThreads(__tstate);
14041 if (PyErr_Occurred()) SWIG_fail;
14042 }
14043 Py_INCREF(Py_None); resultobj = Py_None;
14044 {
14045 if (temp2)
14046 delete arg2;
14047 }
14048 return resultobj;
14049 fail:
14050 {
14051 if (temp2)
14052 delete arg2;
14053 }
14054 return NULL;
14055 }
14056
14057
14058 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
14059 PyObject *resultobj = NULL;
14060 wxImage *arg1 = (wxImage *) 0 ;
14061 wxString *arg2 = 0 ;
14062 wxString result;
14063 bool temp2 = false ;
14064 PyObject * obj0 = 0 ;
14065 PyObject * obj1 = 0 ;
14066 char *kwnames[] = {
14067 (char *) "self",(char *) "name", NULL
14068 };
14069
14070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
14071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14072 if (SWIG_arg_fail(1)) SWIG_fail;
14073 {
14074 arg2 = wxString_in_helper(obj1);
14075 if (arg2 == NULL) SWIG_fail;
14076 temp2 = true;
14077 }
14078 {
14079 PyThreadState* __tstate = wxPyBeginAllowThreads();
14080 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
14081
14082 wxPyEndAllowThreads(__tstate);
14083 if (PyErr_Occurred()) SWIG_fail;
14084 }
14085 {
14086 #if wxUSE_UNICODE
14087 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14088 #else
14089 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14090 #endif
14091 }
14092 {
14093 if (temp2)
14094 delete arg2;
14095 }
14096 return resultobj;
14097 fail:
14098 {
14099 if (temp2)
14100 delete arg2;
14101 }
14102 return NULL;
14103 }
14104
14105
14106 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
14107 PyObject *resultobj = NULL;
14108 wxImage *arg1 = (wxImage *) 0 ;
14109 wxString *arg2 = 0 ;
14110 int result;
14111 bool temp2 = false ;
14112 PyObject * obj0 = 0 ;
14113 PyObject * obj1 = 0 ;
14114 char *kwnames[] = {
14115 (char *) "self",(char *) "name", NULL
14116 };
14117
14118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
14119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14120 if (SWIG_arg_fail(1)) SWIG_fail;
14121 {
14122 arg2 = wxString_in_helper(obj1);
14123 if (arg2 == NULL) SWIG_fail;
14124 temp2 = true;
14125 }
14126 {
14127 PyThreadState* __tstate = wxPyBeginAllowThreads();
14128 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
14129
14130 wxPyEndAllowThreads(__tstate);
14131 if (PyErr_Occurred()) SWIG_fail;
14132 }
14133 {
14134 resultobj = SWIG_From_int(static_cast<int >(result));
14135 }
14136 {
14137 if (temp2)
14138 delete arg2;
14139 }
14140 return resultobj;
14141 fail:
14142 {
14143 if (temp2)
14144 delete arg2;
14145 }
14146 return NULL;
14147 }
14148
14149
14150 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
14151 PyObject *resultobj = NULL;
14152 wxImage *arg1 = (wxImage *) 0 ;
14153 wxString *arg2 = 0 ;
14154 bool result;
14155 bool temp2 = false ;
14156 PyObject * obj0 = 0 ;
14157 PyObject * obj1 = 0 ;
14158 char *kwnames[] = {
14159 (char *) "self",(char *) "name", NULL
14160 };
14161
14162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
14163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14164 if (SWIG_arg_fail(1)) SWIG_fail;
14165 {
14166 arg2 = wxString_in_helper(obj1);
14167 if (arg2 == NULL) SWIG_fail;
14168 temp2 = true;
14169 }
14170 {
14171 PyThreadState* __tstate = wxPyBeginAllowThreads();
14172 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
14173
14174 wxPyEndAllowThreads(__tstate);
14175 if (PyErr_Occurred()) SWIG_fail;
14176 }
14177 {
14178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14179 }
14180 {
14181 if (temp2)
14182 delete arg2;
14183 }
14184 return resultobj;
14185 fail:
14186 {
14187 if (temp2)
14188 delete arg2;
14189 }
14190 return NULL;
14191 }
14192
14193
14194 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
14195 PyObject *resultobj = NULL;
14196 wxImage *arg1 = (wxImage *) 0 ;
14197 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
14198 unsigned long result;
14199 PyObject * obj0 = 0 ;
14200 PyObject * obj1 = 0 ;
14201 char *kwnames[] = {
14202 (char *) "self",(char *) "stopafter", NULL
14203 };
14204
14205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
14206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14207 if (SWIG_arg_fail(1)) SWIG_fail;
14208 if (obj1) {
14209 {
14210 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
14211 if (SWIG_arg_fail(2)) SWIG_fail;
14212 }
14213 }
14214 {
14215 PyThreadState* __tstate = wxPyBeginAllowThreads();
14216 result = (unsigned long)(arg1)->CountColours(arg2);
14217
14218 wxPyEndAllowThreads(__tstate);
14219 if (PyErr_Occurred()) SWIG_fail;
14220 }
14221 {
14222 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
14223 }
14224 return resultobj;
14225 fail:
14226 return NULL;
14227 }
14228
14229
14230 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
14231 PyObject *resultobj = NULL;
14232 wxImage *arg1 = (wxImage *) 0 ;
14233 wxImageHistogram *arg2 = 0 ;
14234 unsigned long result;
14235 PyObject * obj0 = 0 ;
14236 PyObject * obj1 = 0 ;
14237 char *kwnames[] = {
14238 (char *) "self",(char *) "h", NULL
14239 };
14240
14241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
14242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14243 if (SWIG_arg_fail(1)) SWIG_fail;
14244 {
14245 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
14246 if (SWIG_arg_fail(2)) SWIG_fail;
14247 if (arg2 == NULL) {
14248 SWIG_null_ref("wxImageHistogram");
14249 }
14250 if (SWIG_arg_fail(2)) SWIG_fail;
14251 }
14252 {
14253 PyThreadState* __tstate = wxPyBeginAllowThreads();
14254 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
14255
14256 wxPyEndAllowThreads(__tstate);
14257 if (PyErr_Occurred()) SWIG_fail;
14258 }
14259 {
14260 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
14261 }
14262 return resultobj;
14263 fail:
14264 return NULL;
14265 }
14266
14267
14268 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14269 PyObject *resultobj = NULL;
14270 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14271 PyObject * obj0 = 0 ;
14272 char *kwnames[] = {
14273 (char *) "handler", NULL
14274 };
14275
14276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
14277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14278 if (SWIG_arg_fail(1)) SWIG_fail;
14279 {
14280 PyThreadState* __tstate = wxPyBeginAllowThreads();
14281 wxImage::AddHandler(arg1);
14282
14283 wxPyEndAllowThreads(__tstate);
14284 if (PyErr_Occurred()) SWIG_fail;
14285 }
14286 Py_INCREF(Py_None); resultobj = Py_None;
14287 return resultobj;
14288 fail:
14289 return NULL;
14290 }
14291
14292
14293 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14294 PyObject *resultobj = NULL;
14295 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14296 PyObject * obj0 = 0 ;
14297 char *kwnames[] = {
14298 (char *) "handler", NULL
14299 };
14300
14301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
14302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14303 if (SWIG_arg_fail(1)) SWIG_fail;
14304 {
14305 PyThreadState* __tstate = wxPyBeginAllowThreads();
14306 wxImage::InsertHandler(arg1);
14307
14308 wxPyEndAllowThreads(__tstate);
14309 if (PyErr_Occurred()) SWIG_fail;
14310 }
14311 Py_INCREF(Py_None); resultobj = Py_None;
14312 return resultobj;
14313 fail:
14314 return NULL;
14315 }
14316
14317
14318 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14319 PyObject *resultobj = NULL;
14320 wxString *arg1 = 0 ;
14321 bool result;
14322 bool temp1 = false ;
14323 PyObject * obj0 = 0 ;
14324 char *kwnames[] = {
14325 (char *) "name", NULL
14326 };
14327
14328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
14329 {
14330 arg1 = wxString_in_helper(obj0);
14331 if (arg1 == NULL) SWIG_fail;
14332 temp1 = true;
14333 }
14334 {
14335 PyThreadState* __tstate = wxPyBeginAllowThreads();
14336 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
14337
14338 wxPyEndAllowThreads(__tstate);
14339 if (PyErr_Occurred()) SWIG_fail;
14340 }
14341 {
14342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14343 }
14344 {
14345 if (temp1)
14346 delete arg1;
14347 }
14348 return resultobj;
14349 fail:
14350 {
14351 if (temp1)
14352 delete arg1;
14353 }
14354 return NULL;
14355 }
14356
14357
14358 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14359 PyObject *resultobj = NULL;
14360 wxString result;
14361 char *kwnames[] = {
14362 NULL
14363 };
14364
14365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
14366 {
14367 PyThreadState* __tstate = wxPyBeginAllowThreads();
14368 result = wxImage::GetImageExtWildcard();
14369
14370 wxPyEndAllowThreads(__tstate);
14371 if (PyErr_Occurred()) SWIG_fail;
14372 }
14373 {
14374 #if wxUSE_UNICODE
14375 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14376 #else
14377 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14378 #endif
14379 }
14380 return resultobj;
14381 fail:
14382 return NULL;
14383 }
14384
14385
14386 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14387 PyObject *resultobj = NULL;
14388 wxImage *arg1 = (wxImage *) 0 ;
14389 int arg2 = (int) -1 ;
14390 wxBitmap result;
14391 PyObject * obj0 = 0 ;
14392 PyObject * obj1 = 0 ;
14393 char *kwnames[] = {
14394 (char *) "self",(char *) "depth", NULL
14395 };
14396
14397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
14398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14399 if (SWIG_arg_fail(1)) SWIG_fail;
14400 if (obj1) {
14401 {
14402 arg2 = static_cast<int >(SWIG_As_int(obj1));
14403 if (SWIG_arg_fail(2)) SWIG_fail;
14404 }
14405 }
14406 {
14407 if (!wxPyCheckForApp()) SWIG_fail;
14408 PyThreadState* __tstate = wxPyBeginAllowThreads();
14409 result = wxImage_ConvertToBitmap(arg1,arg2);
14410
14411 wxPyEndAllowThreads(__tstate);
14412 if (PyErr_Occurred()) SWIG_fail;
14413 }
14414 {
14415 wxBitmap * resultptr;
14416 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
14417 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14418 }
14419 return resultobj;
14420 fail:
14421 return NULL;
14422 }
14423
14424
14425 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14426 PyObject *resultobj = NULL;
14427 wxImage *arg1 = (wxImage *) 0 ;
14428 byte arg2 ;
14429 byte arg3 ;
14430 byte arg4 ;
14431 wxBitmap result;
14432 PyObject * obj0 = 0 ;
14433 PyObject * obj1 = 0 ;
14434 PyObject * obj2 = 0 ;
14435 PyObject * obj3 = 0 ;
14436 char *kwnames[] = {
14437 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
14438 };
14439
14440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14442 if (SWIG_arg_fail(1)) SWIG_fail;
14443 {
14444 arg2 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj1));
14445 if (SWIG_arg_fail(2)) SWIG_fail;
14446 }
14447 {
14448 arg3 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj2));
14449 if (SWIG_arg_fail(3)) SWIG_fail;
14450 }
14451 {
14452 arg4 = static_cast<byte >(SWIG_As_unsigned_SS_char(obj3));
14453 if (SWIG_arg_fail(4)) SWIG_fail;
14454 }
14455 {
14456 if (!wxPyCheckForApp()) SWIG_fail;
14457 PyThreadState* __tstate = wxPyBeginAllowThreads();
14458 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
14459
14460 wxPyEndAllowThreads(__tstate);
14461 if (PyErr_Occurred()) SWIG_fail;
14462 }
14463 {
14464 wxBitmap * resultptr;
14465 resultptr = new wxBitmap(static_cast<wxBitmap & >(result));
14466 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14467 }
14468 return resultobj;
14469 fail:
14470 return NULL;
14471 }
14472
14473
14474 static PyObject *_wrap_Image_RotateHue(PyObject *, PyObject *args, PyObject *kwargs) {
14475 PyObject *resultobj = NULL;
14476 wxImage *arg1 = (wxImage *) 0 ;
14477 double arg2 ;
14478 PyObject * obj0 = 0 ;
14479 PyObject * obj1 = 0 ;
14480 char *kwnames[] = {
14481 (char *) "self",(char *) "angle", NULL
14482 };
14483
14484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) goto fail;
14485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14486 if (SWIG_arg_fail(1)) SWIG_fail;
14487 {
14488 arg2 = static_cast<double >(SWIG_As_double(obj1));
14489 if (SWIG_arg_fail(2)) SWIG_fail;
14490 }
14491 {
14492 PyThreadState* __tstate = wxPyBeginAllowThreads();
14493 (arg1)->RotateHue(arg2);
14494
14495 wxPyEndAllowThreads(__tstate);
14496 if (PyErr_Occurred()) SWIG_fail;
14497 }
14498 Py_INCREF(Py_None); resultobj = Py_None;
14499 return resultobj;
14500 fail:
14501 return NULL;
14502 }
14503
14504
14505 static PyObject *_wrap_Image_RGBtoHSV(PyObject *, PyObject *args, PyObject *kwargs) {
14506 PyObject *resultobj = NULL;
14507 wxImage_RGBValue arg1 ;
14508 wxImage_HSVValue result;
14509 PyObject * obj0 = 0 ;
14510 char *kwnames[] = {
14511 (char *) "rgb", NULL
14512 };
14513
14514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) goto fail;
14515 {
14516 wxImage_RGBValue * argp;
14517 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION);
14518 if (SWIG_arg_fail(1)) SWIG_fail;
14519 if (argp == NULL) {
14520 SWIG_null_ref("wxImage_RGBValue");
14521 }
14522 if (SWIG_arg_fail(1)) SWIG_fail;
14523 arg1 = *argp;
14524 }
14525 {
14526 PyThreadState* __tstate = wxPyBeginAllowThreads();
14527 result = wxImage::RGBtoHSV(arg1);
14528
14529 wxPyEndAllowThreads(__tstate);
14530 if (PyErr_Occurred()) SWIG_fail;
14531 }
14532 {
14533 wxImage_HSVValue * resultptr;
14534 resultptr = new wxImage_HSVValue(static_cast<wxImage_HSVValue & >(result));
14535 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_HSVValue, 1);
14536 }
14537 return resultobj;
14538 fail:
14539 return NULL;
14540 }
14541
14542
14543 static PyObject *_wrap_Image_HSVtoRGB(PyObject *, PyObject *args, PyObject *kwargs) {
14544 PyObject *resultobj = NULL;
14545 wxImage_HSVValue arg1 ;
14546 wxImage_RGBValue result;
14547 PyObject * obj0 = 0 ;
14548 char *kwnames[] = {
14549 (char *) "hsv", NULL
14550 };
14551
14552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) goto fail;
14553 {
14554 wxImage_HSVValue * argp;
14555 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION);
14556 if (SWIG_arg_fail(1)) SWIG_fail;
14557 if (argp == NULL) {
14558 SWIG_null_ref("wxImage_HSVValue");
14559 }
14560 if (SWIG_arg_fail(1)) SWIG_fail;
14561 arg1 = *argp;
14562 }
14563 {
14564 PyThreadState* __tstate = wxPyBeginAllowThreads();
14565 result = wxImage::HSVtoRGB(arg1);
14566
14567 wxPyEndAllowThreads(__tstate);
14568 if (PyErr_Occurred()) SWIG_fail;
14569 }
14570 {
14571 wxImage_RGBValue * resultptr;
14572 resultptr = new wxImage_RGBValue(static_cast<wxImage_RGBValue & >(result));
14573 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_RGBValue, 1);
14574 }
14575 return resultobj;
14576 fail:
14577 return NULL;
14578 }
14579
14580
14581 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
14582 PyObject *obj;
14583 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14584 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
14585 Py_INCREF(obj);
14586 return Py_BuildValue((char *)"");
14587 }
14588 static int _wrap_NullImage_set(PyObject *) {
14589 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
14590 return 1;
14591 }
14592
14593
14594 static PyObject *_wrap_NullImage_get(void) {
14595 PyObject *pyobj = NULL;
14596
14597 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
14598 return pyobj;
14599 }
14600
14601
14602 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
14603 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
14604 return 1;
14605 }
14606
14607
14608 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
14609 PyObject *pyobj = NULL;
14610
14611 {
14612 #if wxUSE_UNICODE
14613 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14614 #else
14615 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14616 #endif
14617 }
14618 return pyobj;
14619 }
14620
14621
14622 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
14623 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
14624 return 1;
14625 }
14626
14627
14628 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
14629 PyObject *pyobj = NULL;
14630
14631 {
14632 #if wxUSE_UNICODE
14633 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14634 #else
14635 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14636 #endif
14637 }
14638 return pyobj;
14639 }
14640
14641
14642 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
14643 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
14644 return 1;
14645 }
14646
14647
14648 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
14649 PyObject *pyobj = NULL;
14650
14651 {
14652 #if wxUSE_UNICODE
14653 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14654 #else
14655 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14656 #endif
14657 }
14658 return pyobj;
14659 }
14660
14661
14662 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
14663 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
14664 return 1;
14665 }
14666
14667
14668 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
14669 PyObject *pyobj = NULL;
14670
14671 {
14672 #if wxUSE_UNICODE
14673 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14674 #else
14675 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14676 #endif
14677 }
14678 return pyobj;
14679 }
14680
14681
14682 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
14683 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
14684 return 1;
14685 }
14686
14687
14688 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
14689 PyObject *pyobj = NULL;
14690
14691 {
14692 #if wxUSE_UNICODE
14693 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14694 #else
14695 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14696 #endif
14697 }
14698 return pyobj;
14699 }
14700
14701
14702 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
14703 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
14704 return 1;
14705 }
14706
14707
14708 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
14709 PyObject *pyobj = NULL;
14710
14711 {
14712 #if wxUSE_UNICODE
14713 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14714 #else
14715 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14716 #endif
14717 }
14718 return pyobj;
14719 }
14720
14721
14722 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
14723 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
14724 return 1;
14725 }
14726
14727
14728 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
14729 PyObject *pyobj = NULL;
14730
14731 {
14732 #if wxUSE_UNICODE
14733 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14734 #else
14735 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14736 #endif
14737 }
14738 return pyobj;
14739 }
14740
14741
14742 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
14743 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
14744 return 1;
14745 }
14746
14747
14748 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
14749 PyObject *pyobj = NULL;
14750
14751 {
14752 #if wxUSE_UNICODE
14753 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14754 #else
14755 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14756 #endif
14757 }
14758 return pyobj;
14759 }
14760
14761
14762 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14763 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14764 return 1;
14765 }
14766
14767
14768 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14769 PyObject *pyobj = NULL;
14770
14771 {
14772 #if wxUSE_UNICODE
14773 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14774 #else
14775 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14776 #endif
14777 }
14778 return pyobj;
14779 }
14780
14781
14782 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14783 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14784 return 1;
14785 }
14786
14787
14788 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14789 PyObject *pyobj = NULL;
14790
14791 {
14792 #if wxUSE_UNICODE
14793 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14794 #else
14795 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14796 #endif
14797 }
14798 return pyobj;
14799 }
14800
14801
14802 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14803 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14804 return 1;
14805 }
14806
14807
14808 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14809 PyObject *pyobj = NULL;
14810
14811 {
14812 #if wxUSE_UNICODE
14813 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14814 #else
14815 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14816 #endif
14817 }
14818 return pyobj;
14819 }
14820
14821
14822 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14823 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14824 return 1;
14825 }
14826
14827
14828 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14829 PyObject *pyobj = NULL;
14830
14831 {
14832 #if wxUSE_UNICODE
14833 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14834 #else
14835 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14836 #endif
14837 }
14838 return pyobj;
14839 }
14840
14841
14842 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14843 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14844 return 1;
14845 }
14846
14847
14848 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14849 PyObject *pyobj = NULL;
14850
14851 {
14852 #if wxUSE_UNICODE
14853 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14854 #else
14855 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14856 #endif
14857 }
14858 return pyobj;
14859 }
14860
14861
14862 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14863 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14864 return 1;
14865 }
14866
14867
14868 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14869 PyObject *pyobj = NULL;
14870
14871 {
14872 #if wxUSE_UNICODE
14873 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14874 #else
14875 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14876 #endif
14877 }
14878 return pyobj;
14879 }
14880
14881
14882 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14883 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14884 return 1;
14885 }
14886
14887
14888 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14889 PyObject *pyobj = NULL;
14890
14891 {
14892 #if wxUSE_UNICODE
14893 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14894 #else
14895 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14896 #endif
14897 }
14898 return pyobj;
14899 }
14900
14901
14902 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14903 PyObject *resultobj = NULL;
14904 wxBMPHandler *result;
14905 char *kwnames[] = {
14906 NULL
14907 };
14908
14909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14910 {
14911 PyThreadState* __tstate = wxPyBeginAllowThreads();
14912 result = (wxBMPHandler *)new wxBMPHandler();
14913
14914 wxPyEndAllowThreads(__tstate);
14915 if (PyErr_Occurred()) SWIG_fail;
14916 }
14917 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14918 return resultobj;
14919 fail:
14920 return NULL;
14921 }
14922
14923
14924 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14925 PyObject *obj;
14926 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14927 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14928 Py_INCREF(obj);
14929 return Py_BuildValue((char *)"");
14930 }
14931 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14932 PyObject *resultobj = NULL;
14933 wxICOHandler *result;
14934 char *kwnames[] = {
14935 NULL
14936 };
14937
14938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14939 {
14940 PyThreadState* __tstate = wxPyBeginAllowThreads();
14941 result = (wxICOHandler *)new wxICOHandler();
14942
14943 wxPyEndAllowThreads(__tstate);
14944 if (PyErr_Occurred()) SWIG_fail;
14945 }
14946 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14947 return resultobj;
14948 fail:
14949 return NULL;
14950 }
14951
14952
14953 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14954 PyObject *obj;
14955 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14956 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14957 Py_INCREF(obj);
14958 return Py_BuildValue((char *)"");
14959 }
14960 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14961 PyObject *resultobj = NULL;
14962 wxCURHandler *result;
14963 char *kwnames[] = {
14964 NULL
14965 };
14966
14967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14968 {
14969 PyThreadState* __tstate = wxPyBeginAllowThreads();
14970 result = (wxCURHandler *)new wxCURHandler();
14971
14972 wxPyEndAllowThreads(__tstate);
14973 if (PyErr_Occurred()) SWIG_fail;
14974 }
14975 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14976 return resultobj;
14977 fail:
14978 return NULL;
14979 }
14980
14981
14982 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14983 PyObject *obj;
14984 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14985 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14986 Py_INCREF(obj);
14987 return Py_BuildValue((char *)"");
14988 }
14989 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14990 PyObject *resultobj = NULL;
14991 wxANIHandler *result;
14992 char *kwnames[] = {
14993 NULL
14994 };
14995
14996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14997 {
14998 PyThreadState* __tstate = wxPyBeginAllowThreads();
14999 result = (wxANIHandler *)new wxANIHandler();
15000
15001 wxPyEndAllowThreads(__tstate);
15002 if (PyErr_Occurred()) SWIG_fail;
15003 }
15004 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
15005 return resultobj;
15006 fail:
15007 return NULL;
15008 }
15009
15010
15011 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
15012 PyObject *obj;
15013 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15014 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
15015 Py_INCREF(obj);
15016 return Py_BuildValue((char *)"");
15017 }
15018 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15019 PyObject *resultobj = NULL;
15020 wxPNGHandler *result;
15021 char *kwnames[] = {
15022 NULL
15023 };
15024
15025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
15026 {
15027 PyThreadState* __tstate = wxPyBeginAllowThreads();
15028 result = (wxPNGHandler *)new wxPNGHandler();
15029
15030 wxPyEndAllowThreads(__tstate);
15031 if (PyErr_Occurred()) SWIG_fail;
15032 }
15033 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
15034 return resultobj;
15035 fail:
15036 return NULL;
15037 }
15038
15039
15040 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
15041 PyObject *obj;
15042 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15043 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
15044 Py_INCREF(obj);
15045 return Py_BuildValue((char *)"");
15046 }
15047 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15048 PyObject *resultobj = NULL;
15049 wxGIFHandler *result;
15050 char *kwnames[] = {
15051 NULL
15052 };
15053
15054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
15055 {
15056 PyThreadState* __tstate = wxPyBeginAllowThreads();
15057 result = (wxGIFHandler *)new wxGIFHandler();
15058
15059 wxPyEndAllowThreads(__tstate);
15060 if (PyErr_Occurred()) SWIG_fail;
15061 }
15062 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
15063 return resultobj;
15064 fail:
15065 return NULL;
15066 }
15067
15068
15069 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
15070 PyObject *obj;
15071 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15072 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
15073 Py_INCREF(obj);
15074 return Py_BuildValue((char *)"");
15075 }
15076 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15077 PyObject *resultobj = NULL;
15078 wxPCXHandler *result;
15079 char *kwnames[] = {
15080 NULL
15081 };
15082
15083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
15084 {
15085 PyThreadState* __tstate = wxPyBeginAllowThreads();
15086 result = (wxPCXHandler *)new wxPCXHandler();
15087
15088 wxPyEndAllowThreads(__tstate);
15089 if (PyErr_Occurred()) SWIG_fail;
15090 }
15091 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
15092 return resultobj;
15093 fail:
15094 return NULL;
15095 }
15096
15097
15098 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
15099 PyObject *obj;
15100 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15101 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
15102 Py_INCREF(obj);
15103 return Py_BuildValue((char *)"");
15104 }
15105 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15106 PyObject *resultobj = NULL;
15107 wxJPEGHandler *result;
15108 char *kwnames[] = {
15109 NULL
15110 };
15111
15112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
15113 {
15114 PyThreadState* __tstate = wxPyBeginAllowThreads();
15115 result = (wxJPEGHandler *)new wxJPEGHandler();
15116
15117 wxPyEndAllowThreads(__tstate);
15118 if (PyErr_Occurred()) SWIG_fail;
15119 }
15120 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
15121 return resultobj;
15122 fail:
15123 return NULL;
15124 }
15125
15126
15127 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
15128 PyObject *obj;
15129 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15130 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
15131 Py_INCREF(obj);
15132 return Py_BuildValue((char *)"");
15133 }
15134 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15135 PyObject *resultobj = NULL;
15136 wxPNMHandler *result;
15137 char *kwnames[] = {
15138 NULL
15139 };
15140
15141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
15142 {
15143 PyThreadState* __tstate = wxPyBeginAllowThreads();
15144 result = (wxPNMHandler *)new wxPNMHandler();
15145
15146 wxPyEndAllowThreads(__tstate);
15147 if (PyErr_Occurred()) SWIG_fail;
15148 }
15149 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
15150 return resultobj;
15151 fail:
15152 return NULL;
15153 }
15154
15155
15156 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
15157 PyObject *obj;
15158 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15159 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
15160 Py_INCREF(obj);
15161 return Py_BuildValue((char *)"");
15162 }
15163 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15164 PyObject *resultobj = NULL;
15165 wxXPMHandler *result;
15166 char *kwnames[] = {
15167 NULL
15168 };
15169
15170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
15171 {
15172 PyThreadState* __tstate = wxPyBeginAllowThreads();
15173 result = (wxXPMHandler *)new wxXPMHandler();
15174
15175 wxPyEndAllowThreads(__tstate);
15176 if (PyErr_Occurred()) SWIG_fail;
15177 }
15178 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
15179 return resultobj;
15180 fail:
15181 return NULL;
15182 }
15183
15184
15185 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
15186 PyObject *obj;
15187 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15188 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
15189 Py_INCREF(obj);
15190 return Py_BuildValue((char *)"");
15191 }
15192 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15193 PyObject *resultobj = NULL;
15194 wxTIFFHandler *result;
15195 char *kwnames[] = {
15196 NULL
15197 };
15198
15199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
15200 {
15201 PyThreadState* __tstate = wxPyBeginAllowThreads();
15202 result = (wxTIFFHandler *)new wxTIFFHandler();
15203
15204 wxPyEndAllowThreads(__tstate);
15205 if (PyErr_Occurred()) SWIG_fail;
15206 }
15207 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
15208 return resultobj;
15209 fail:
15210 return NULL;
15211 }
15212
15213
15214 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
15215 PyObject *obj;
15216 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15217 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
15218 Py_INCREF(obj);
15219 return Py_BuildValue((char *)"");
15220 }
15221 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
15222 PyObject *resultobj = NULL;
15223 wxImage *arg1 = 0 ;
15224 wxImage *arg2 = 0 ;
15225 int arg3 = (int) 236 ;
15226 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
15227 bool result;
15228 PyObject * obj0 = 0 ;
15229 PyObject * obj1 = 0 ;
15230 PyObject * obj2 = 0 ;
15231 PyObject * obj3 = 0 ;
15232 char *kwnames[] = {
15233 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
15234 };
15235
15236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15237 {
15238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15239 if (SWIG_arg_fail(1)) SWIG_fail;
15240 if (arg1 == NULL) {
15241 SWIG_null_ref("wxImage");
15242 }
15243 if (SWIG_arg_fail(1)) SWIG_fail;
15244 }
15245 {
15246 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
15247 if (SWIG_arg_fail(2)) SWIG_fail;
15248 if (arg2 == NULL) {
15249 SWIG_null_ref("wxImage");
15250 }
15251 if (SWIG_arg_fail(2)) SWIG_fail;
15252 }
15253 if (obj2) {
15254 {
15255 arg3 = static_cast<int >(SWIG_As_int(obj2));
15256 if (SWIG_arg_fail(3)) SWIG_fail;
15257 }
15258 }
15259 if (obj3) {
15260 {
15261 arg4 = static_cast<int >(SWIG_As_int(obj3));
15262 if (SWIG_arg_fail(4)) SWIG_fail;
15263 }
15264 }
15265 {
15266 PyThreadState* __tstate = wxPyBeginAllowThreads();
15267 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
15268
15269 wxPyEndAllowThreads(__tstate);
15270 if (PyErr_Occurred()) SWIG_fail;
15271 }
15272 {
15273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15274 }
15275 return resultobj;
15276 fail:
15277 return NULL;
15278 }
15279
15280
15281 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
15282 PyObject *obj;
15283 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15284 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
15285 Py_INCREF(obj);
15286 return Py_BuildValue((char *)"");
15287 }
15288 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15289 PyObject *resultobj = NULL;
15290 wxEvtHandler *result;
15291 char *kwnames[] = {
15292 NULL
15293 };
15294
15295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
15296 {
15297 PyThreadState* __tstate = wxPyBeginAllowThreads();
15298 result = (wxEvtHandler *)new wxEvtHandler();
15299
15300 wxPyEndAllowThreads(__tstate);
15301 if (PyErr_Occurred()) SWIG_fail;
15302 }
15303 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
15304 return resultobj;
15305 fail:
15306 return NULL;
15307 }
15308
15309
15310 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15311 PyObject *resultobj = NULL;
15312 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15313 wxEvtHandler *result;
15314 PyObject * obj0 = 0 ;
15315 char *kwnames[] = {
15316 (char *) "self", NULL
15317 };
15318
15319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
15320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15321 if (SWIG_arg_fail(1)) SWIG_fail;
15322 {
15323 PyThreadState* __tstate = wxPyBeginAllowThreads();
15324 result = (wxEvtHandler *)(arg1)->GetNextHandler();
15325
15326 wxPyEndAllowThreads(__tstate);
15327 if (PyErr_Occurred()) SWIG_fail;
15328 }
15329 {
15330 resultobj = wxPyMake_wxObject(result, 0);
15331 }
15332 return resultobj;
15333 fail:
15334 return NULL;
15335 }
15336
15337
15338 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15339 PyObject *resultobj = NULL;
15340 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15341 wxEvtHandler *result;
15342 PyObject * obj0 = 0 ;
15343 char *kwnames[] = {
15344 (char *) "self", NULL
15345 };
15346
15347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
15348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15349 if (SWIG_arg_fail(1)) SWIG_fail;
15350 {
15351 PyThreadState* __tstate = wxPyBeginAllowThreads();
15352 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
15353
15354 wxPyEndAllowThreads(__tstate);
15355 if (PyErr_Occurred()) SWIG_fail;
15356 }
15357 {
15358 resultobj = wxPyMake_wxObject(result, 0);
15359 }
15360 return resultobj;
15361 fail:
15362 return NULL;
15363 }
15364
15365
15366 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15367 PyObject *resultobj = NULL;
15368 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15369 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15370 PyObject * obj0 = 0 ;
15371 PyObject * obj1 = 0 ;
15372 char *kwnames[] = {
15373 (char *) "self",(char *) "handler", NULL
15374 };
15375
15376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
15377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15378 if (SWIG_arg_fail(1)) SWIG_fail;
15379 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15380 if (SWIG_arg_fail(2)) SWIG_fail;
15381 {
15382 PyThreadState* __tstate = wxPyBeginAllowThreads();
15383 (arg1)->SetNextHandler(arg2);
15384
15385 wxPyEndAllowThreads(__tstate);
15386 if (PyErr_Occurred()) SWIG_fail;
15387 }
15388 Py_INCREF(Py_None); resultobj = Py_None;
15389 return resultobj;
15390 fail:
15391 return NULL;
15392 }
15393
15394
15395 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15396 PyObject *resultobj = NULL;
15397 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15398 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15399 PyObject * obj0 = 0 ;
15400 PyObject * obj1 = 0 ;
15401 char *kwnames[] = {
15402 (char *) "self",(char *) "handler", NULL
15403 };
15404
15405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
15406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15407 if (SWIG_arg_fail(1)) SWIG_fail;
15408 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15409 if (SWIG_arg_fail(2)) SWIG_fail;
15410 {
15411 PyThreadState* __tstate = wxPyBeginAllowThreads();
15412 (arg1)->SetPreviousHandler(arg2);
15413
15414 wxPyEndAllowThreads(__tstate);
15415 if (PyErr_Occurred()) SWIG_fail;
15416 }
15417 Py_INCREF(Py_None); resultobj = Py_None;
15418 return resultobj;
15419 fail:
15420 return NULL;
15421 }
15422
15423
15424 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15425 PyObject *resultobj = NULL;
15426 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15427 bool result;
15428 PyObject * obj0 = 0 ;
15429 char *kwnames[] = {
15430 (char *) "self", NULL
15431 };
15432
15433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
15434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15435 if (SWIG_arg_fail(1)) SWIG_fail;
15436 {
15437 PyThreadState* __tstate = wxPyBeginAllowThreads();
15438 result = (bool)(arg1)->GetEvtHandlerEnabled();
15439
15440 wxPyEndAllowThreads(__tstate);
15441 if (PyErr_Occurred()) SWIG_fail;
15442 }
15443 {
15444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15445 }
15446 return resultobj;
15447 fail:
15448 return NULL;
15449 }
15450
15451
15452 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15453 PyObject *resultobj = NULL;
15454 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15455 bool arg2 ;
15456 PyObject * obj0 = 0 ;
15457 PyObject * obj1 = 0 ;
15458 char *kwnames[] = {
15459 (char *) "self",(char *) "enabled", NULL
15460 };
15461
15462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
15463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15464 if (SWIG_arg_fail(1)) SWIG_fail;
15465 {
15466 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
15467 if (SWIG_arg_fail(2)) SWIG_fail;
15468 }
15469 {
15470 PyThreadState* __tstate = wxPyBeginAllowThreads();
15471 (arg1)->SetEvtHandlerEnabled(arg2);
15472
15473 wxPyEndAllowThreads(__tstate);
15474 if (PyErr_Occurred()) SWIG_fail;
15475 }
15476 Py_INCREF(Py_None); resultobj = Py_None;
15477 return resultobj;
15478 fail:
15479 return NULL;
15480 }
15481
15482
15483 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15484 PyObject *resultobj = NULL;
15485 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15486 wxEvent *arg2 = 0 ;
15487 bool result;
15488 PyObject * obj0 = 0 ;
15489 PyObject * obj1 = 0 ;
15490 char *kwnames[] = {
15491 (char *) "self",(char *) "event", NULL
15492 };
15493
15494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
15495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15496 if (SWIG_arg_fail(1)) SWIG_fail;
15497 {
15498 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15499 if (SWIG_arg_fail(2)) SWIG_fail;
15500 if (arg2 == NULL) {
15501 SWIG_null_ref("wxEvent");
15502 }
15503 if (SWIG_arg_fail(2)) SWIG_fail;
15504 }
15505 {
15506 PyThreadState* __tstate = wxPyBeginAllowThreads();
15507 result = (bool)(arg1)->ProcessEvent(*arg2);
15508
15509 wxPyEndAllowThreads(__tstate);
15510 if (PyErr_Occurred()) SWIG_fail;
15511 }
15512 {
15513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15514 }
15515 return resultobj;
15516 fail:
15517 return NULL;
15518 }
15519
15520
15521 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15522 PyObject *resultobj = NULL;
15523 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15524 wxEvent *arg2 = 0 ;
15525 PyObject * obj0 = 0 ;
15526 PyObject * obj1 = 0 ;
15527 char *kwnames[] = {
15528 (char *) "self",(char *) "event", NULL
15529 };
15530
15531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
15532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15533 if (SWIG_arg_fail(1)) SWIG_fail;
15534 {
15535 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15536 if (SWIG_arg_fail(2)) SWIG_fail;
15537 if (arg2 == NULL) {
15538 SWIG_null_ref("wxEvent");
15539 }
15540 if (SWIG_arg_fail(2)) SWIG_fail;
15541 }
15542 {
15543 PyThreadState* __tstate = wxPyBeginAllowThreads();
15544 (arg1)->AddPendingEvent(*arg2);
15545
15546 wxPyEndAllowThreads(__tstate);
15547 if (PyErr_Occurred()) SWIG_fail;
15548 }
15549 Py_INCREF(Py_None); resultobj = Py_None;
15550 return resultobj;
15551 fail:
15552 return NULL;
15553 }
15554
15555
15556 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
15557 PyObject *resultobj = NULL;
15558 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15559 PyObject * obj0 = 0 ;
15560 char *kwnames[] = {
15561 (char *) "self", NULL
15562 };
15563
15564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
15565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15566 if (SWIG_arg_fail(1)) SWIG_fail;
15567 {
15568 PyThreadState* __tstate = wxPyBeginAllowThreads();
15569 (arg1)->ProcessPendingEvents();
15570
15571 wxPyEndAllowThreads(__tstate);
15572 if (PyErr_Occurred()) SWIG_fail;
15573 }
15574 Py_INCREF(Py_None); resultobj = Py_None;
15575 return resultobj;
15576 fail:
15577 return NULL;
15578 }
15579
15580
15581 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
15582 PyObject *resultobj = NULL;
15583 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15584 int arg2 ;
15585 int arg3 ;
15586 int arg4 ;
15587 PyObject *arg5 = (PyObject *) 0 ;
15588 PyObject * obj0 = 0 ;
15589 PyObject * obj1 = 0 ;
15590 PyObject * obj2 = 0 ;
15591 PyObject * obj3 = 0 ;
15592 PyObject * obj4 = 0 ;
15593 char *kwnames[] = {
15594 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
15595 };
15596
15597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15599 if (SWIG_arg_fail(1)) SWIG_fail;
15600 {
15601 arg2 = static_cast<int >(SWIG_As_int(obj1));
15602 if (SWIG_arg_fail(2)) SWIG_fail;
15603 }
15604 {
15605 arg3 = static_cast<int >(SWIG_As_int(obj2));
15606 if (SWIG_arg_fail(3)) SWIG_fail;
15607 }
15608 {
15609 arg4 = static_cast<int >(SWIG_As_int(obj3));
15610 if (SWIG_arg_fail(4)) SWIG_fail;
15611 }
15612 arg5 = obj4;
15613 {
15614 PyThreadState* __tstate = wxPyBeginAllowThreads();
15615 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
15616
15617 wxPyEndAllowThreads(__tstate);
15618 if (PyErr_Occurred()) SWIG_fail;
15619 }
15620 Py_INCREF(Py_None); resultobj = Py_None;
15621 return resultobj;
15622 fail:
15623 return NULL;
15624 }
15625
15626
15627 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
15628 PyObject *resultobj = NULL;
15629 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15630 int arg2 ;
15631 int arg3 = (int) -1 ;
15632 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
15633 bool result;
15634 PyObject * obj0 = 0 ;
15635 PyObject * obj1 = 0 ;
15636 PyObject * obj2 = 0 ;
15637 PyObject * obj3 = 0 ;
15638 char *kwnames[] = {
15639 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
15640 };
15641
15642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15644 if (SWIG_arg_fail(1)) SWIG_fail;
15645 {
15646 arg2 = static_cast<int >(SWIG_As_int(obj1));
15647 if (SWIG_arg_fail(2)) SWIG_fail;
15648 }
15649 if (obj2) {
15650 {
15651 arg3 = static_cast<int >(SWIG_As_int(obj2));
15652 if (SWIG_arg_fail(3)) SWIG_fail;
15653 }
15654 }
15655 if (obj3) {
15656 {
15657 arg4 = static_cast<wxEventType >(SWIG_As_int(obj3));
15658 if (SWIG_arg_fail(4)) SWIG_fail;
15659 }
15660 }
15661 {
15662 PyThreadState* __tstate = wxPyBeginAllowThreads();
15663 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
15664
15665 wxPyEndAllowThreads(__tstate);
15666 if (PyErr_Occurred()) SWIG_fail;
15667 }
15668 {
15669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15670 }
15671 return resultobj;
15672 fail:
15673 return NULL;
15674 }
15675
15676
15677 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
15678 PyObject *resultobj = NULL;
15679 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15680 PyObject *arg2 = (PyObject *) 0 ;
15681 bool arg3 = (bool) true ;
15682 PyObject * obj0 = 0 ;
15683 PyObject * obj1 = 0 ;
15684 PyObject * obj2 = 0 ;
15685 char *kwnames[] = {
15686 (char *) "self",(char *) "_self",(char *) "incref", NULL
15687 };
15688
15689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
15690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15691 if (SWIG_arg_fail(1)) SWIG_fail;
15692 arg2 = obj1;
15693 if (obj2) {
15694 {
15695 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
15696 if (SWIG_arg_fail(3)) SWIG_fail;
15697 }
15698 }
15699 {
15700 PyThreadState* __tstate = wxPyBeginAllowThreads();
15701 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
15702
15703 wxPyEndAllowThreads(__tstate);
15704 if (PyErr_Occurred()) SWIG_fail;
15705 }
15706 Py_INCREF(Py_None); resultobj = Py_None;
15707 return resultobj;
15708 fail:
15709 return NULL;
15710 }
15711
15712
15713 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
15714 PyObject *obj;
15715 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15716 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
15717 Py_INCREF(obj);
15718 return Py_BuildValue((char *)"");
15719 }
15720 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15721 PyObject *resultobj = NULL;
15722 wxEventType result;
15723 char *kwnames[] = {
15724 NULL
15725 };
15726
15727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
15728 {
15729 PyThreadState* __tstate = wxPyBeginAllowThreads();
15730 result = (wxEventType)wxNewEventType();
15731
15732 wxPyEndAllowThreads(__tstate);
15733 if (PyErr_Occurred()) SWIG_fail;
15734 }
15735 {
15736 resultobj = SWIG_From_int(static_cast<int >(result));
15737 }
15738 return resultobj;
15739 fail:
15740 return NULL;
15741 }
15742
15743
15744 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
15745 PyObject *resultobj = NULL;
15746 wxEvent *arg1 = (wxEvent *) 0 ;
15747 PyObject * obj0 = 0 ;
15748 char *kwnames[] = {
15749 (char *) "self", NULL
15750 };
15751
15752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
15753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15754 if (SWIG_arg_fail(1)) SWIG_fail;
15755 {
15756 PyThreadState* __tstate = wxPyBeginAllowThreads();
15757 delete arg1;
15758
15759 wxPyEndAllowThreads(__tstate);
15760 if (PyErr_Occurred()) SWIG_fail;
15761 }
15762 Py_INCREF(Py_None); resultobj = Py_None;
15763 return resultobj;
15764 fail:
15765 return NULL;
15766 }
15767
15768
15769 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15770 PyObject *resultobj = NULL;
15771 wxEvent *arg1 = (wxEvent *) 0 ;
15772 wxEventType arg2 ;
15773 PyObject * obj0 = 0 ;
15774 PyObject * obj1 = 0 ;
15775 char *kwnames[] = {
15776 (char *) "self",(char *) "typ", NULL
15777 };
15778
15779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15781 if (SWIG_arg_fail(1)) SWIG_fail;
15782 {
15783 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
15784 if (SWIG_arg_fail(2)) SWIG_fail;
15785 }
15786 {
15787 PyThreadState* __tstate = wxPyBeginAllowThreads();
15788 (arg1)->SetEventType(arg2);
15789
15790 wxPyEndAllowThreads(__tstate);
15791 if (PyErr_Occurred()) SWIG_fail;
15792 }
15793 Py_INCREF(Py_None); resultobj = Py_None;
15794 return resultobj;
15795 fail:
15796 return NULL;
15797 }
15798
15799
15800 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15801 PyObject *resultobj = NULL;
15802 wxEvent *arg1 = (wxEvent *) 0 ;
15803 wxEventType result;
15804 PyObject * obj0 = 0 ;
15805 char *kwnames[] = {
15806 (char *) "self", NULL
15807 };
15808
15809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15811 if (SWIG_arg_fail(1)) SWIG_fail;
15812 {
15813 PyThreadState* __tstate = wxPyBeginAllowThreads();
15814 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15815
15816 wxPyEndAllowThreads(__tstate);
15817 if (PyErr_Occurred()) SWIG_fail;
15818 }
15819 {
15820 resultobj = SWIG_From_int(static_cast<int >(result));
15821 }
15822 return resultobj;
15823 fail:
15824 return NULL;
15825 }
15826
15827
15828 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15829 PyObject *resultobj = NULL;
15830 wxEvent *arg1 = (wxEvent *) 0 ;
15831 wxObject *result;
15832 PyObject * obj0 = 0 ;
15833 char *kwnames[] = {
15834 (char *) "self", NULL
15835 };
15836
15837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15839 if (SWIG_arg_fail(1)) SWIG_fail;
15840 {
15841 PyThreadState* __tstate = wxPyBeginAllowThreads();
15842 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15843
15844 wxPyEndAllowThreads(__tstate);
15845 if (PyErr_Occurred()) SWIG_fail;
15846 }
15847 {
15848 resultobj = wxPyMake_wxObject(result, (bool)0);
15849 }
15850 return resultobj;
15851 fail:
15852 return NULL;
15853 }
15854
15855
15856 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15857 PyObject *resultobj = NULL;
15858 wxEvent *arg1 = (wxEvent *) 0 ;
15859 wxObject *arg2 = (wxObject *) 0 ;
15860 PyObject * obj0 = 0 ;
15861 PyObject * obj1 = 0 ;
15862 char *kwnames[] = {
15863 (char *) "self",(char *) "obj", NULL
15864 };
15865
15866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15868 if (SWIG_arg_fail(1)) SWIG_fail;
15869 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15870 if (SWIG_arg_fail(2)) SWIG_fail;
15871 {
15872 PyThreadState* __tstate = wxPyBeginAllowThreads();
15873 (arg1)->SetEventObject(arg2);
15874
15875 wxPyEndAllowThreads(__tstate);
15876 if (PyErr_Occurred()) SWIG_fail;
15877 }
15878 Py_INCREF(Py_None); resultobj = Py_None;
15879 return resultobj;
15880 fail:
15881 return NULL;
15882 }
15883
15884
15885 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15886 PyObject *resultobj = NULL;
15887 wxEvent *arg1 = (wxEvent *) 0 ;
15888 long result;
15889 PyObject * obj0 = 0 ;
15890 char *kwnames[] = {
15891 (char *) "self", NULL
15892 };
15893
15894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15896 if (SWIG_arg_fail(1)) SWIG_fail;
15897 {
15898 PyThreadState* __tstate = wxPyBeginAllowThreads();
15899 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15900
15901 wxPyEndAllowThreads(__tstate);
15902 if (PyErr_Occurred()) SWIG_fail;
15903 }
15904 {
15905 resultobj = SWIG_From_long(static_cast<long >(result));
15906 }
15907 return resultobj;
15908 fail:
15909 return NULL;
15910 }
15911
15912
15913 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15914 PyObject *resultobj = NULL;
15915 wxEvent *arg1 = (wxEvent *) 0 ;
15916 long arg2 = (long) 0 ;
15917 PyObject * obj0 = 0 ;
15918 PyObject * obj1 = 0 ;
15919 char *kwnames[] = {
15920 (char *) "self",(char *) "ts", NULL
15921 };
15922
15923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15925 if (SWIG_arg_fail(1)) SWIG_fail;
15926 if (obj1) {
15927 {
15928 arg2 = static_cast<long >(SWIG_As_long(obj1));
15929 if (SWIG_arg_fail(2)) SWIG_fail;
15930 }
15931 }
15932 {
15933 PyThreadState* __tstate = wxPyBeginAllowThreads();
15934 (arg1)->SetTimestamp(arg2);
15935
15936 wxPyEndAllowThreads(__tstate);
15937 if (PyErr_Occurred()) SWIG_fail;
15938 }
15939 Py_INCREF(Py_None); resultobj = Py_None;
15940 return resultobj;
15941 fail:
15942 return NULL;
15943 }
15944
15945
15946 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15947 PyObject *resultobj = NULL;
15948 wxEvent *arg1 = (wxEvent *) 0 ;
15949 int result;
15950 PyObject * obj0 = 0 ;
15951 char *kwnames[] = {
15952 (char *) "self", NULL
15953 };
15954
15955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15957 if (SWIG_arg_fail(1)) SWIG_fail;
15958 {
15959 PyThreadState* __tstate = wxPyBeginAllowThreads();
15960 result = (int)((wxEvent const *)arg1)->GetId();
15961
15962 wxPyEndAllowThreads(__tstate);
15963 if (PyErr_Occurred()) SWIG_fail;
15964 }
15965 {
15966 resultobj = SWIG_From_int(static_cast<int >(result));
15967 }
15968 return resultobj;
15969 fail:
15970 return NULL;
15971 }
15972
15973
15974 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15975 PyObject *resultobj = NULL;
15976 wxEvent *arg1 = (wxEvent *) 0 ;
15977 int arg2 ;
15978 PyObject * obj0 = 0 ;
15979 PyObject * obj1 = 0 ;
15980 char *kwnames[] = {
15981 (char *) "self",(char *) "Id", NULL
15982 };
15983
15984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15986 if (SWIG_arg_fail(1)) SWIG_fail;
15987 {
15988 arg2 = static_cast<int >(SWIG_As_int(obj1));
15989 if (SWIG_arg_fail(2)) SWIG_fail;
15990 }
15991 {
15992 PyThreadState* __tstate = wxPyBeginAllowThreads();
15993 (arg1)->SetId(arg2);
15994
15995 wxPyEndAllowThreads(__tstate);
15996 if (PyErr_Occurred()) SWIG_fail;
15997 }
15998 Py_INCREF(Py_None); resultobj = Py_None;
15999 return resultobj;
16000 fail:
16001 return NULL;
16002 }
16003
16004
16005 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16006 PyObject *resultobj = NULL;
16007 wxEvent *arg1 = (wxEvent *) 0 ;
16008 bool result;
16009 PyObject * obj0 = 0 ;
16010 char *kwnames[] = {
16011 (char *) "self", NULL
16012 };
16013
16014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
16015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16016 if (SWIG_arg_fail(1)) SWIG_fail;
16017 {
16018 PyThreadState* __tstate = wxPyBeginAllowThreads();
16019 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
16020
16021 wxPyEndAllowThreads(__tstate);
16022 if (PyErr_Occurred()) SWIG_fail;
16023 }
16024 {
16025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16026 }
16027 return resultobj;
16028 fail:
16029 return NULL;
16030 }
16031
16032
16033 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
16034 PyObject *resultobj = NULL;
16035 wxEvent *arg1 = (wxEvent *) 0 ;
16036 bool arg2 = (bool) true ;
16037 PyObject * obj0 = 0 ;
16038 PyObject * obj1 = 0 ;
16039 char *kwnames[] = {
16040 (char *) "self",(char *) "skip", NULL
16041 };
16042
16043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
16044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16045 if (SWIG_arg_fail(1)) SWIG_fail;
16046 if (obj1) {
16047 {
16048 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
16049 if (SWIG_arg_fail(2)) SWIG_fail;
16050 }
16051 }
16052 {
16053 PyThreadState* __tstate = wxPyBeginAllowThreads();
16054 (arg1)->Skip(arg2);
16055
16056 wxPyEndAllowThreads(__tstate);
16057 if (PyErr_Occurred()) SWIG_fail;
16058 }
16059 Py_INCREF(Py_None); resultobj = Py_None;
16060 return resultobj;
16061 fail:
16062 return NULL;
16063 }
16064
16065
16066 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
16067 PyObject *resultobj = NULL;
16068 wxEvent *arg1 = (wxEvent *) 0 ;
16069 bool result;
16070 PyObject * obj0 = 0 ;
16071 char *kwnames[] = {
16072 (char *) "self", NULL
16073 };
16074
16075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
16076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16077 if (SWIG_arg_fail(1)) SWIG_fail;
16078 {
16079 PyThreadState* __tstate = wxPyBeginAllowThreads();
16080 result = (bool)((wxEvent const *)arg1)->GetSkipped();
16081
16082 wxPyEndAllowThreads(__tstate);
16083 if (PyErr_Occurred()) SWIG_fail;
16084 }
16085 {
16086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16087 }
16088 return resultobj;
16089 fail:
16090 return NULL;
16091 }
16092
16093
16094 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
16095 PyObject *resultobj = NULL;
16096 wxEvent *arg1 = (wxEvent *) 0 ;
16097 bool result;
16098 PyObject * obj0 = 0 ;
16099 char *kwnames[] = {
16100 (char *) "self", NULL
16101 };
16102
16103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
16104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16105 if (SWIG_arg_fail(1)) SWIG_fail;
16106 {
16107 PyThreadState* __tstate = wxPyBeginAllowThreads();
16108 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
16109
16110 wxPyEndAllowThreads(__tstate);
16111 if (PyErr_Occurred()) SWIG_fail;
16112 }
16113 {
16114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16115 }
16116 return resultobj;
16117 fail:
16118 return NULL;
16119 }
16120
16121
16122 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
16123 PyObject *resultobj = NULL;
16124 wxEvent *arg1 = (wxEvent *) 0 ;
16125 int result;
16126 PyObject * obj0 = 0 ;
16127 char *kwnames[] = {
16128 (char *) "self", NULL
16129 };
16130
16131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
16132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16133 if (SWIG_arg_fail(1)) SWIG_fail;
16134 {
16135 PyThreadState* __tstate = wxPyBeginAllowThreads();
16136 result = (int)(arg1)->StopPropagation();
16137
16138 wxPyEndAllowThreads(__tstate);
16139 if (PyErr_Occurred()) SWIG_fail;
16140 }
16141 {
16142 resultobj = SWIG_From_int(static_cast<int >(result));
16143 }
16144 return resultobj;
16145 fail:
16146 return NULL;
16147 }
16148
16149
16150 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
16151 PyObject *resultobj = NULL;
16152 wxEvent *arg1 = (wxEvent *) 0 ;
16153 int arg2 ;
16154 PyObject * obj0 = 0 ;
16155 PyObject * obj1 = 0 ;
16156 char *kwnames[] = {
16157 (char *) "self",(char *) "propagationLevel", NULL
16158 };
16159
16160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
16161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16162 if (SWIG_arg_fail(1)) SWIG_fail;
16163 {
16164 arg2 = static_cast<int >(SWIG_As_int(obj1));
16165 if (SWIG_arg_fail(2)) SWIG_fail;
16166 }
16167 {
16168 PyThreadState* __tstate = wxPyBeginAllowThreads();
16169 (arg1)->ResumePropagation(arg2);
16170
16171 wxPyEndAllowThreads(__tstate);
16172 if (PyErr_Occurred()) SWIG_fail;
16173 }
16174 Py_INCREF(Py_None); resultobj = Py_None;
16175 return resultobj;
16176 fail:
16177 return NULL;
16178 }
16179
16180
16181 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16182 PyObject *resultobj = NULL;
16183 wxEvent *arg1 = (wxEvent *) 0 ;
16184 wxEvent *result;
16185 PyObject * obj0 = 0 ;
16186 char *kwnames[] = {
16187 (char *) "self", NULL
16188 };
16189
16190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
16191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16192 if (SWIG_arg_fail(1)) SWIG_fail;
16193 {
16194 PyThreadState* __tstate = wxPyBeginAllowThreads();
16195 result = (wxEvent *)(arg1)->Clone();
16196
16197 wxPyEndAllowThreads(__tstate);
16198 if (PyErr_Occurred()) SWIG_fail;
16199 }
16200 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16201 return resultobj;
16202 fail:
16203 return NULL;
16204 }
16205
16206
16207 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
16208 PyObject *obj;
16209 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16210 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
16211 Py_INCREF(obj);
16212 return Py_BuildValue((char *)"");
16213 }
16214 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16215 PyObject *resultobj = NULL;
16216 wxEvent *arg1 = 0 ;
16217 wxPropagationDisabler *result;
16218 PyObject * obj0 = 0 ;
16219 char *kwnames[] = {
16220 (char *) "event", NULL
16221 };
16222
16223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
16224 {
16225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16226 if (SWIG_arg_fail(1)) SWIG_fail;
16227 if (arg1 == NULL) {
16228 SWIG_null_ref("wxEvent");
16229 }
16230 if (SWIG_arg_fail(1)) SWIG_fail;
16231 }
16232 {
16233 PyThreadState* __tstate = wxPyBeginAllowThreads();
16234 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
16235
16236 wxPyEndAllowThreads(__tstate);
16237 if (PyErr_Occurred()) SWIG_fail;
16238 }
16239 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
16240 return resultobj;
16241 fail:
16242 return NULL;
16243 }
16244
16245
16246 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
16247 PyObject *resultobj = NULL;
16248 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
16249 PyObject * obj0 = 0 ;
16250 char *kwnames[] = {
16251 (char *) "self", NULL
16252 };
16253
16254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
16255 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
16256 if (SWIG_arg_fail(1)) SWIG_fail;
16257 {
16258 PyThreadState* __tstate = wxPyBeginAllowThreads();
16259 delete arg1;
16260
16261 wxPyEndAllowThreads(__tstate);
16262 if (PyErr_Occurred()) SWIG_fail;
16263 }
16264 Py_INCREF(Py_None); resultobj = Py_None;
16265 return resultobj;
16266 fail:
16267 return NULL;
16268 }
16269
16270
16271 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
16272 PyObject *obj;
16273 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16274 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
16275 Py_INCREF(obj);
16276 return Py_BuildValue((char *)"");
16277 }
16278 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16279 PyObject *resultobj = NULL;
16280 wxEvent *arg1 = 0 ;
16281 wxPropagateOnce *result;
16282 PyObject * obj0 = 0 ;
16283 char *kwnames[] = {
16284 (char *) "event", NULL
16285 };
16286
16287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
16288 {
16289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16290 if (SWIG_arg_fail(1)) SWIG_fail;
16291 if (arg1 == NULL) {
16292 SWIG_null_ref("wxEvent");
16293 }
16294 if (SWIG_arg_fail(1)) SWIG_fail;
16295 }
16296 {
16297 PyThreadState* __tstate = wxPyBeginAllowThreads();
16298 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
16299
16300 wxPyEndAllowThreads(__tstate);
16301 if (PyErr_Occurred()) SWIG_fail;
16302 }
16303 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
16304 return resultobj;
16305 fail:
16306 return NULL;
16307 }
16308
16309
16310 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16311 PyObject *resultobj = NULL;
16312 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
16313 PyObject * obj0 = 0 ;
16314 char *kwnames[] = {
16315 (char *) "self", NULL
16316 };
16317
16318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
16319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
16320 if (SWIG_arg_fail(1)) SWIG_fail;
16321 {
16322 PyThreadState* __tstate = wxPyBeginAllowThreads();
16323 delete arg1;
16324
16325 wxPyEndAllowThreads(__tstate);
16326 if (PyErr_Occurred()) SWIG_fail;
16327 }
16328 Py_INCREF(Py_None); resultobj = Py_None;
16329 return resultobj;
16330 fail:
16331 return NULL;
16332 }
16333
16334
16335 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
16336 PyObject *obj;
16337 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16338 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
16339 Py_INCREF(obj);
16340 return Py_BuildValue((char *)"");
16341 }
16342 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16343 PyObject *resultobj = NULL;
16344 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16345 int arg2 = (int) 0 ;
16346 wxCommandEvent *result;
16347 PyObject * obj0 = 0 ;
16348 PyObject * obj1 = 0 ;
16349 char *kwnames[] = {
16350 (char *) "commandType",(char *) "winid", NULL
16351 };
16352
16353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
16354 if (obj0) {
16355 {
16356 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16357 if (SWIG_arg_fail(1)) SWIG_fail;
16358 }
16359 }
16360 if (obj1) {
16361 {
16362 arg2 = static_cast<int >(SWIG_As_int(obj1));
16363 if (SWIG_arg_fail(2)) SWIG_fail;
16364 }
16365 }
16366 {
16367 PyThreadState* __tstate = wxPyBeginAllowThreads();
16368 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
16369
16370 wxPyEndAllowThreads(__tstate);
16371 if (PyErr_Occurred()) SWIG_fail;
16372 }
16373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
16374 return resultobj;
16375 fail:
16376 return NULL;
16377 }
16378
16379
16380 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16381 PyObject *resultobj = NULL;
16382 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16383 int result;
16384 PyObject * obj0 = 0 ;
16385 char *kwnames[] = {
16386 (char *) "self", NULL
16387 };
16388
16389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
16390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16391 if (SWIG_arg_fail(1)) SWIG_fail;
16392 {
16393 PyThreadState* __tstate = wxPyBeginAllowThreads();
16394 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
16395
16396 wxPyEndAllowThreads(__tstate);
16397 if (PyErr_Occurred()) SWIG_fail;
16398 }
16399 {
16400 resultobj = SWIG_From_int(static_cast<int >(result));
16401 }
16402 return resultobj;
16403 fail:
16404 return NULL;
16405 }
16406
16407
16408 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
16409 PyObject *resultobj = NULL;
16410 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16411 wxString *arg2 = 0 ;
16412 bool temp2 = false ;
16413 PyObject * obj0 = 0 ;
16414 PyObject * obj1 = 0 ;
16415 char *kwnames[] = {
16416 (char *) "self",(char *) "s", NULL
16417 };
16418
16419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
16420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16421 if (SWIG_arg_fail(1)) SWIG_fail;
16422 {
16423 arg2 = wxString_in_helper(obj1);
16424 if (arg2 == NULL) SWIG_fail;
16425 temp2 = true;
16426 }
16427 {
16428 PyThreadState* __tstate = wxPyBeginAllowThreads();
16429 (arg1)->SetString((wxString const &)*arg2);
16430
16431 wxPyEndAllowThreads(__tstate);
16432 if (PyErr_Occurred()) SWIG_fail;
16433 }
16434 Py_INCREF(Py_None); resultobj = Py_None;
16435 {
16436 if (temp2)
16437 delete arg2;
16438 }
16439 return resultobj;
16440 fail:
16441 {
16442 if (temp2)
16443 delete arg2;
16444 }
16445 return NULL;
16446 }
16447
16448
16449 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
16450 PyObject *resultobj = NULL;
16451 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16452 wxString result;
16453 PyObject * obj0 = 0 ;
16454 char *kwnames[] = {
16455 (char *) "self", NULL
16456 };
16457
16458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
16459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16460 if (SWIG_arg_fail(1)) SWIG_fail;
16461 {
16462 PyThreadState* __tstate = wxPyBeginAllowThreads();
16463 result = ((wxCommandEvent const *)arg1)->GetString();
16464
16465 wxPyEndAllowThreads(__tstate);
16466 if (PyErr_Occurred()) SWIG_fail;
16467 }
16468 {
16469 #if wxUSE_UNICODE
16470 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16471 #else
16472 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16473 #endif
16474 }
16475 return resultobj;
16476 fail:
16477 return NULL;
16478 }
16479
16480
16481 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
16482 PyObject *resultobj = NULL;
16483 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16484 bool result;
16485 PyObject * obj0 = 0 ;
16486 char *kwnames[] = {
16487 (char *) "self", NULL
16488 };
16489
16490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
16491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16492 if (SWIG_arg_fail(1)) SWIG_fail;
16493 {
16494 PyThreadState* __tstate = wxPyBeginAllowThreads();
16495 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
16496
16497 wxPyEndAllowThreads(__tstate);
16498 if (PyErr_Occurred()) SWIG_fail;
16499 }
16500 {
16501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16502 }
16503 return resultobj;
16504 fail:
16505 return NULL;
16506 }
16507
16508
16509 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16510 PyObject *resultobj = NULL;
16511 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16512 bool result;
16513 PyObject * obj0 = 0 ;
16514 char *kwnames[] = {
16515 (char *) "self", NULL
16516 };
16517
16518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
16519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16520 if (SWIG_arg_fail(1)) SWIG_fail;
16521 {
16522 PyThreadState* __tstate = wxPyBeginAllowThreads();
16523 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
16524
16525 wxPyEndAllowThreads(__tstate);
16526 if (PyErr_Occurred()) SWIG_fail;
16527 }
16528 {
16529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16530 }
16531 return resultobj;
16532 fail:
16533 return NULL;
16534 }
16535
16536
16537 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16538 PyObject *resultobj = NULL;
16539 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16540 long arg2 ;
16541 PyObject * obj0 = 0 ;
16542 PyObject * obj1 = 0 ;
16543 char *kwnames[] = {
16544 (char *) "self",(char *) "extraLong", NULL
16545 };
16546
16547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
16548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16549 if (SWIG_arg_fail(1)) SWIG_fail;
16550 {
16551 arg2 = static_cast<long >(SWIG_As_long(obj1));
16552 if (SWIG_arg_fail(2)) SWIG_fail;
16553 }
16554 {
16555 PyThreadState* __tstate = wxPyBeginAllowThreads();
16556 (arg1)->SetExtraLong(arg2);
16557
16558 wxPyEndAllowThreads(__tstate);
16559 if (PyErr_Occurred()) SWIG_fail;
16560 }
16561 Py_INCREF(Py_None); resultobj = Py_None;
16562 return resultobj;
16563 fail:
16564 return NULL;
16565 }
16566
16567
16568 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16569 PyObject *resultobj = NULL;
16570 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16571 long result;
16572 PyObject * obj0 = 0 ;
16573 char *kwnames[] = {
16574 (char *) "self", NULL
16575 };
16576
16577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
16578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16579 if (SWIG_arg_fail(1)) SWIG_fail;
16580 {
16581 PyThreadState* __tstate = wxPyBeginAllowThreads();
16582 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
16583
16584 wxPyEndAllowThreads(__tstate);
16585 if (PyErr_Occurred()) SWIG_fail;
16586 }
16587 {
16588 resultobj = SWIG_From_long(static_cast<long >(result));
16589 }
16590 return resultobj;
16591 fail:
16592 return NULL;
16593 }
16594
16595
16596 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16597 PyObject *resultobj = NULL;
16598 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16599 int arg2 ;
16600 PyObject * obj0 = 0 ;
16601 PyObject * obj1 = 0 ;
16602 char *kwnames[] = {
16603 (char *) "self",(char *) "i", NULL
16604 };
16605
16606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
16607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16608 if (SWIG_arg_fail(1)) SWIG_fail;
16609 {
16610 arg2 = static_cast<int >(SWIG_As_int(obj1));
16611 if (SWIG_arg_fail(2)) SWIG_fail;
16612 }
16613 {
16614 PyThreadState* __tstate = wxPyBeginAllowThreads();
16615 (arg1)->SetInt(arg2);
16616
16617 wxPyEndAllowThreads(__tstate);
16618 if (PyErr_Occurred()) SWIG_fail;
16619 }
16620 Py_INCREF(Py_None); resultobj = Py_None;
16621 return resultobj;
16622 fail:
16623 return NULL;
16624 }
16625
16626
16627 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16628 PyObject *resultobj = NULL;
16629 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16630 long result;
16631 PyObject * obj0 = 0 ;
16632 char *kwnames[] = {
16633 (char *) "self", NULL
16634 };
16635
16636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
16637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16638 if (SWIG_arg_fail(1)) SWIG_fail;
16639 {
16640 PyThreadState* __tstate = wxPyBeginAllowThreads();
16641 result = (long)((wxCommandEvent const *)arg1)->GetInt();
16642
16643 wxPyEndAllowThreads(__tstate);
16644 if (PyErr_Occurred()) SWIG_fail;
16645 }
16646 {
16647 resultobj = SWIG_From_long(static_cast<long >(result));
16648 }
16649 return resultobj;
16650 fail:
16651 return NULL;
16652 }
16653
16654
16655 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16656 PyObject *resultobj = NULL;
16657 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16658 wxEvent *result;
16659 PyObject * obj0 = 0 ;
16660 char *kwnames[] = {
16661 (char *) "self", NULL
16662 };
16663
16664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
16665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16666 if (SWIG_arg_fail(1)) SWIG_fail;
16667 {
16668 PyThreadState* __tstate = wxPyBeginAllowThreads();
16669 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
16670
16671 wxPyEndAllowThreads(__tstate);
16672 if (PyErr_Occurred()) SWIG_fail;
16673 }
16674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16675 return resultobj;
16676 fail:
16677 return NULL;
16678 }
16679
16680
16681 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
16682 PyObject *obj;
16683 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16684 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
16685 Py_INCREF(obj);
16686 return Py_BuildValue((char *)"");
16687 }
16688 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16689 PyObject *resultobj = NULL;
16690 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16691 int arg2 = (int) 0 ;
16692 wxNotifyEvent *result;
16693 PyObject * obj0 = 0 ;
16694 PyObject * obj1 = 0 ;
16695 char *kwnames[] = {
16696 (char *) "commandType",(char *) "winid", NULL
16697 };
16698
16699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
16700 if (obj0) {
16701 {
16702 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16703 if (SWIG_arg_fail(1)) SWIG_fail;
16704 }
16705 }
16706 if (obj1) {
16707 {
16708 arg2 = static_cast<int >(SWIG_As_int(obj1));
16709 if (SWIG_arg_fail(2)) SWIG_fail;
16710 }
16711 }
16712 {
16713 PyThreadState* __tstate = wxPyBeginAllowThreads();
16714 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
16715
16716 wxPyEndAllowThreads(__tstate);
16717 if (PyErr_Occurred()) SWIG_fail;
16718 }
16719 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
16720 return resultobj;
16721 fail:
16722 return NULL;
16723 }
16724
16725
16726 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
16727 PyObject *resultobj = NULL;
16728 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16729 PyObject * obj0 = 0 ;
16730 char *kwnames[] = {
16731 (char *) "self", NULL
16732 };
16733
16734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
16735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16736 if (SWIG_arg_fail(1)) SWIG_fail;
16737 {
16738 PyThreadState* __tstate = wxPyBeginAllowThreads();
16739 (arg1)->Veto();
16740
16741 wxPyEndAllowThreads(__tstate);
16742 if (PyErr_Occurred()) SWIG_fail;
16743 }
16744 Py_INCREF(Py_None); resultobj = Py_None;
16745 return resultobj;
16746 fail:
16747 return NULL;
16748 }
16749
16750
16751 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
16752 PyObject *resultobj = NULL;
16753 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16754 PyObject * obj0 = 0 ;
16755 char *kwnames[] = {
16756 (char *) "self", NULL
16757 };
16758
16759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16761 if (SWIG_arg_fail(1)) SWIG_fail;
16762 {
16763 PyThreadState* __tstate = wxPyBeginAllowThreads();
16764 (arg1)->Allow();
16765
16766 wxPyEndAllowThreads(__tstate);
16767 if (PyErr_Occurred()) SWIG_fail;
16768 }
16769 Py_INCREF(Py_None); resultobj = Py_None;
16770 return resultobj;
16771 fail:
16772 return NULL;
16773 }
16774
16775
16776 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16777 PyObject *resultobj = NULL;
16778 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16779 bool result;
16780 PyObject * obj0 = 0 ;
16781 char *kwnames[] = {
16782 (char *) "self", NULL
16783 };
16784
16785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16787 if (SWIG_arg_fail(1)) SWIG_fail;
16788 {
16789 PyThreadState* __tstate = wxPyBeginAllowThreads();
16790 result = (bool)(arg1)->IsAllowed();
16791
16792 wxPyEndAllowThreads(__tstate);
16793 if (PyErr_Occurred()) SWIG_fail;
16794 }
16795 {
16796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16797 }
16798 return resultobj;
16799 fail:
16800 return NULL;
16801 }
16802
16803
16804 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16805 PyObject *obj;
16806 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16807 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16808 Py_INCREF(obj);
16809 return Py_BuildValue((char *)"");
16810 }
16811 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16812 PyObject *resultobj = NULL;
16813 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16814 int arg2 = (int) 0 ;
16815 int arg3 = (int) 0 ;
16816 int arg4 = (int) 0 ;
16817 wxScrollEvent *result;
16818 PyObject * obj0 = 0 ;
16819 PyObject * obj1 = 0 ;
16820 PyObject * obj2 = 0 ;
16821 PyObject * obj3 = 0 ;
16822 char *kwnames[] = {
16823 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16824 };
16825
16826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16827 if (obj0) {
16828 {
16829 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
16830 if (SWIG_arg_fail(1)) SWIG_fail;
16831 }
16832 }
16833 if (obj1) {
16834 {
16835 arg2 = static_cast<int >(SWIG_As_int(obj1));
16836 if (SWIG_arg_fail(2)) SWIG_fail;
16837 }
16838 }
16839 if (obj2) {
16840 {
16841 arg3 = static_cast<int >(SWIG_As_int(obj2));
16842 if (SWIG_arg_fail(3)) SWIG_fail;
16843 }
16844 }
16845 if (obj3) {
16846 {
16847 arg4 = static_cast<int >(SWIG_As_int(obj3));
16848 if (SWIG_arg_fail(4)) SWIG_fail;
16849 }
16850 }
16851 {
16852 PyThreadState* __tstate = wxPyBeginAllowThreads();
16853 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16854
16855 wxPyEndAllowThreads(__tstate);
16856 if (PyErr_Occurred()) SWIG_fail;
16857 }
16858 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16859 return resultobj;
16860 fail:
16861 return NULL;
16862 }
16863
16864
16865 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16866 PyObject *resultobj = NULL;
16867 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16868 int result;
16869 PyObject * obj0 = 0 ;
16870 char *kwnames[] = {
16871 (char *) "self", NULL
16872 };
16873
16874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16876 if (SWIG_arg_fail(1)) SWIG_fail;
16877 {
16878 PyThreadState* __tstate = wxPyBeginAllowThreads();
16879 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16880
16881 wxPyEndAllowThreads(__tstate);
16882 if (PyErr_Occurred()) SWIG_fail;
16883 }
16884 {
16885 resultobj = SWIG_From_int(static_cast<int >(result));
16886 }
16887 return resultobj;
16888 fail:
16889 return NULL;
16890 }
16891
16892
16893 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16894 PyObject *resultobj = NULL;
16895 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16896 int result;
16897 PyObject * obj0 = 0 ;
16898 char *kwnames[] = {
16899 (char *) "self", NULL
16900 };
16901
16902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16904 if (SWIG_arg_fail(1)) SWIG_fail;
16905 {
16906 PyThreadState* __tstate = wxPyBeginAllowThreads();
16907 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16908
16909 wxPyEndAllowThreads(__tstate);
16910 if (PyErr_Occurred()) SWIG_fail;
16911 }
16912 {
16913 resultobj = SWIG_From_int(static_cast<int >(result));
16914 }
16915 return resultobj;
16916 fail:
16917 return NULL;
16918 }
16919
16920
16921 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16922 PyObject *resultobj = NULL;
16923 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16924 int arg2 ;
16925 PyObject * obj0 = 0 ;
16926 PyObject * obj1 = 0 ;
16927 char *kwnames[] = {
16928 (char *) "self",(char *) "orient", NULL
16929 };
16930
16931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16933 if (SWIG_arg_fail(1)) SWIG_fail;
16934 {
16935 arg2 = static_cast<int >(SWIG_As_int(obj1));
16936 if (SWIG_arg_fail(2)) SWIG_fail;
16937 }
16938 {
16939 PyThreadState* __tstate = wxPyBeginAllowThreads();
16940 (arg1)->SetOrientation(arg2);
16941
16942 wxPyEndAllowThreads(__tstate);
16943 if (PyErr_Occurred()) SWIG_fail;
16944 }
16945 Py_INCREF(Py_None); resultobj = Py_None;
16946 return resultobj;
16947 fail:
16948 return NULL;
16949 }
16950
16951
16952 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16953 PyObject *resultobj = NULL;
16954 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16955 int arg2 ;
16956 PyObject * obj0 = 0 ;
16957 PyObject * obj1 = 0 ;
16958 char *kwnames[] = {
16959 (char *) "self",(char *) "pos", NULL
16960 };
16961
16962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16964 if (SWIG_arg_fail(1)) SWIG_fail;
16965 {
16966 arg2 = static_cast<int >(SWIG_As_int(obj1));
16967 if (SWIG_arg_fail(2)) SWIG_fail;
16968 }
16969 {
16970 PyThreadState* __tstate = wxPyBeginAllowThreads();
16971 (arg1)->SetPosition(arg2);
16972
16973 wxPyEndAllowThreads(__tstate);
16974 if (PyErr_Occurred()) SWIG_fail;
16975 }
16976 Py_INCREF(Py_None); resultobj = Py_None;
16977 return resultobj;
16978 fail:
16979 return NULL;
16980 }
16981
16982
16983 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16984 PyObject *obj;
16985 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16986 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16987 Py_INCREF(obj);
16988 return Py_BuildValue((char *)"");
16989 }
16990 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16991 PyObject *resultobj = NULL;
16992 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16993 int arg2 = (int) 0 ;
16994 int arg3 = (int) 0 ;
16995 wxScrollWinEvent *result;
16996 PyObject * obj0 = 0 ;
16997 PyObject * obj1 = 0 ;
16998 PyObject * obj2 = 0 ;
16999 char *kwnames[] = {
17000 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
17001 };
17002
17003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
17004 if (obj0) {
17005 {
17006 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
17007 if (SWIG_arg_fail(1)) SWIG_fail;
17008 }
17009 }
17010 if (obj1) {
17011 {
17012 arg2 = static_cast<int >(SWIG_As_int(obj1));
17013 if (SWIG_arg_fail(2)) SWIG_fail;
17014 }
17015 }
17016 if (obj2) {
17017 {
17018 arg3 = static_cast<int >(SWIG_As_int(obj2));
17019 if (SWIG_arg_fail(3)) SWIG_fail;
17020 }
17021 }
17022 {
17023 PyThreadState* __tstate = wxPyBeginAllowThreads();
17024 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
17025
17026 wxPyEndAllowThreads(__tstate);
17027 if (PyErr_Occurred()) SWIG_fail;
17028 }
17029 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
17030 return resultobj;
17031 fail:
17032 return NULL;
17033 }
17034
17035
17036 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17037 PyObject *resultobj = NULL;
17038 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17039 int result;
17040 PyObject * obj0 = 0 ;
17041 char *kwnames[] = {
17042 (char *) "self", NULL
17043 };
17044
17045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
17046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17047 if (SWIG_arg_fail(1)) SWIG_fail;
17048 {
17049 PyThreadState* __tstate = wxPyBeginAllowThreads();
17050 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
17051
17052 wxPyEndAllowThreads(__tstate);
17053 if (PyErr_Occurred()) SWIG_fail;
17054 }
17055 {
17056 resultobj = SWIG_From_int(static_cast<int >(result));
17057 }
17058 return resultobj;
17059 fail:
17060 return NULL;
17061 }
17062
17063
17064 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17065 PyObject *resultobj = NULL;
17066 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17067 int result;
17068 PyObject * obj0 = 0 ;
17069 char *kwnames[] = {
17070 (char *) "self", NULL
17071 };
17072
17073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
17074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17075 if (SWIG_arg_fail(1)) SWIG_fail;
17076 {
17077 PyThreadState* __tstate = wxPyBeginAllowThreads();
17078 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
17079
17080 wxPyEndAllowThreads(__tstate);
17081 if (PyErr_Occurred()) SWIG_fail;
17082 }
17083 {
17084 resultobj = SWIG_From_int(static_cast<int >(result));
17085 }
17086 return resultobj;
17087 fail:
17088 return NULL;
17089 }
17090
17091
17092 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
17093 PyObject *resultobj = NULL;
17094 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17095 int arg2 ;
17096 PyObject * obj0 = 0 ;
17097 PyObject * obj1 = 0 ;
17098 char *kwnames[] = {
17099 (char *) "self",(char *) "orient", NULL
17100 };
17101
17102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
17103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17104 if (SWIG_arg_fail(1)) SWIG_fail;
17105 {
17106 arg2 = static_cast<int >(SWIG_As_int(obj1));
17107 if (SWIG_arg_fail(2)) SWIG_fail;
17108 }
17109 {
17110 PyThreadState* __tstate = wxPyBeginAllowThreads();
17111 (arg1)->SetOrientation(arg2);
17112
17113 wxPyEndAllowThreads(__tstate);
17114 if (PyErr_Occurred()) SWIG_fail;
17115 }
17116 Py_INCREF(Py_None); resultobj = Py_None;
17117 return resultobj;
17118 fail:
17119 return NULL;
17120 }
17121
17122
17123 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17124 PyObject *resultobj = NULL;
17125 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
17126 int arg2 ;
17127 PyObject * obj0 = 0 ;
17128 PyObject * obj1 = 0 ;
17129 char *kwnames[] = {
17130 (char *) "self",(char *) "pos", NULL
17131 };
17132
17133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
17134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
17135 if (SWIG_arg_fail(1)) SWIG_fail;
17136 {
17137 arg2 = static_cast<int >(SWIG_As_int(obj1));
17138 if (SWIG_arg_fail(2)) SWIG_fail;
17139 }
17140 {
17141 PyThreadState* __tstate = wxPyBeginAllowThreads();
17142 (arg1)->SetPosition(arg2);
17143
17144 wxPyEndAllowThreads(__tstate);
17145 if (PyErr_Occurred()) SWIG_fail;
17146 }
17147 Py_INCREF(Py_None); resultobj = Py_None;
17148 return resultobj;
17149 fail:
17150 return NULL;
17151 }
17152
17153
17154 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
17155 PyObject *obj;
17156 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17157 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
17158 Py_INCREF(obj);
17159 return Py_BuildValue((char *)"");
17160 }
17161 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17162 PyObject *resultobj = NULL;
17163 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17164 wxMouseEvent *result;
17165 PyObject * obj0 = 0 ;
17166 char *kwnames[] = {
17167 (char *) "mouseType", NULL
17168 };
17169
17170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
17171 if (obj0) {
17172 {
17173 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
17174 if (SWIG_arg_fail(1)) SWIG_fail;
17175 }
17176 }
17177 {
17178 PyThreadState* __tstate = wxPyBeginAllowThreads();
17179 result = (wxMouseEvent *)new wxMouseEvent(arg1);
17180
17181 wxPyEndAllowThreads(__tstate);
17182 if (PyErr_Occurred()) SWIG_fail;
17183 }
17184 {
17185 resultobj = wxPyMake_wxObject(result, (bool)1);
17186 }
17187 return resultobj;
17188 fail:
17189 return NULL;
17190 }
17191
17192
17193 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
17194 PyObject *resultobj = NULL;
17195 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17196 bool result;
17197 PyObject * obj0 = 0 ;
17198 char *kwnames[] = {
17199 (char *) "self", NULL
17200 };
17201
17202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
17203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17204 if (SWIG_arg_fail(1)) SWIG_fail;
17205 {
17206 PyThreadState* __tstate = wxPyBeginAllowThreads();
17207 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
17208
17209 wxPyEndAllowThreads(__tstate);
17210 if (PyErr_Occurred()) SWIG_fail;
17211 }
17212 {
17213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17214 }
17215 return resultobj;
17216 fail:
17217 return NULL;
17218 }
17219
17220
17221 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
17222 PyObject *resultobj = NULL;
17223 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17224 int arg2 = (int) wxMOUSE_BTN_ANY ;
17225 bool result;
17226 PyObject * obj0 = 0 ;
17227 PyObject * obj1 = 0 ;
17228 char *kwnames[] = {
17229 (char *) "self",(char *) "but", NULL
17230 };
17231
17232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
17233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17234 if (SWIG_arg_fail(1)) SWIG_fail;
17235 if (obj1) {
17236 {
17237 arg2 = static_cast<int >(SWIG_As_int(obj1));
17238 if (SWIG_arg_fail(2)) SWIG_fail;
17239 }
17240 }
17241 {
17242 PyThreadState* __tstate = wxPyBeginAllowThreads();
17243 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
17244
17245 wxPyEndAllowThreads(__tstate);
17246 if (PyErr_Occurred()) SWIG_fail;
17247 }
17248 {
17249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17250 }
17251 return resultobj;
17252 fail:
17253 return NULL;
17254 }
17255
17256
17257 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17258 PyObject *resultobj = NULL;
17259 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17260 int arg2 = (int) wxMOUSE_BTN_ANY ;
17261 bool result;
17262 PyObject * obj0 = 0 ;
17263 PyObject * obj1 = 0 ;
17264 char *kwnames[] = {
17265 (char *) "self",(char *) "but", NULL
17266 };
17267
17268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
17269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17270 if (SWIG_arg_fail(1)) SWIG_fail;
17271 if (obj1) {
17272 {
17273 arg2 = static_cast<int >(SWIG_As_int(obj1));
17274 if (SWIG_arg_fail(2)) SWIG_fail;
17275 }
17276 }
17277 {
17278 PyThreadState* __tstate = wxPyBeginAllowThreads();
17279 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
17280
17281 wxPyEndAllowThreads(__tstate);
17282 if (PyErr_Occurred()) SWIG_fail;
17283 }
17284 {
17285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17286 }
17287 return resultobj;
17288 fail:
17289 return NULL;
17290 }
17291
17292
17293 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
17294 PyObject *resultobj = NULL;
17295 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17296 int arg2 = (int) wxMOUSE_BTN_ANY ;
17297 bool result;
17298 PyObject * obj0 = 0 ;
17299 PyObject * obj1 = 0 ;
17300 char *kwnames[] = {
17301 (char *) "self",(char *) "but", NULL
17302 };
17303
17304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
17305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17306 if (SWIG_arg_fail(1)) SWIG_fail;
17307 if (obj1) {
17308 {
17309 arg2 = static_cast<int >(SWIG_As_int(obj1));
17310 if (SWIG_arg_fail(2)) SWIG_fail;
17311 }
17312 }
17313 {
17314 PyThreadState* __tstate = wxPyBeginAllowThreads();
17315 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
17316
17317 wxPyEndAllowThreads(__tstate);
17318 if (PyErr_Occurred()) SWIG_fail;
17319 }
17320 {
17321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17322 }
17323 return resultobj;
17324 fail:
17325 return NULL;
17326 }
17327
17328
17329 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
17330 PyObject *resultobj = NULL;
17331 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17332 int arg2 ;
17333 bool result;
17334 PyObject * obj0 = 0 ;
17335 PyObject * obj1 = 0 ;
17336 char *kwnames[] = {
17337 (char *) "self",(char *) "button", NULL
17338 };
17339
17340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
17341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17342 if (SWIG_arg_fail(1)) SWIG_fail;
17343 {
17344 arg2 = static_cast<int >(SWIG_As_int(obj1));
17345 if (SWIG_arg_fail(2)) SWIG_fail;
17346 }
17347 {
17348 PyThreadState* __tstate = wxPyBeginAllowThreads();
17349 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
17350
17351 wxPyEndAllowThreads(__tstate);
17352 if (PyErr_Occurred()) SWIG_fail;
17353 }
17354 {
17355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17356 }
17357 return resultobj;
17358 fail:
17359 return NULL;
17360 }
17361
17362
17363 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17364 PyObject *resultobj = NULL;
17365 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17366 int arg2 ;
17367 bool result;
17368 PyObject * obj0 = 0 ;
17369 PyObject * obj1 = 0 ;
17370 char *kwnames[] = {
17371 (char *) "self",(char *) "but", NULL
17372 };
17373
17374 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
17375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17376 if (SWIG_arg_fail(1)) SWIG_fail;
17377 {
17378 arg2 = static_cast<int >(SWIG_As_int(obj1));
17379 if (SWIG_arg_fail(2)) SWIG_fail;
17380 }
17381 {
17382 PyThreadState* __tstate = wxPyBeginAllowThreads();
17383 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
17384
17385 wxPyEndAllowThreads(__tstate);
17386 if (PyErr_Occurred()) SWIG_fail;
17387 }
17388 {
17389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17390 }
17391 return resultobj;
17392 fail:
17393 return NULL;
17394 }
17395
17396
17397 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
17398 PyObject *resultobj = NULL;
17399 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17400 int result;
17401 PyObject * obj0 = 0 ;
17402 char *kwnames[] = {
17403 (char *) "self", NULL
17404 };
17405
17406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
17407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17408 if (SWIG_arg_fail(1)) SWIG_fail;
17409 {
17410 PyThreadState* __tstate = wxPyBeginAllowThreads();
17411 result = (int)((wxMouseEvent const *)arg1)->GetButton();
17412
17413 wxPyEndAllowThreads(__tstate);
17414 if (PyErr_Occurred()) SWIG_fail;
17415 }
17416 {
17417 resultobj = SWIG_From_int(static_cast<int >(result));
17418 }
17419 return resultobj;
17420 fail:
17421 return NULL;
17422 }
17423
17424
17425 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17426 PyObject *resultobj = NULL;
17427 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17428 bool result;
17429 PyObject * obj0 = 0 ;
17430 char *kwnames[] = {
17431 (char *) "self", NULL
17432 };
17433
17434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
17435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17436 if (SWIG_arg_fail(1)) SWIG_fail;
17437 {
17438 PyThreadState* __tstate = wxPyBeginAllowThreads();
17439 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
17440
17441 wxPyEndAllowThreads(__tstate);
17442 if (PyErr_Occurred()) SWIG_fail;
17443 }
17444 {
17445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17446 }
17447 return resultobj;
17448 fail:
17449 return NULL;
17450 }
17451
17452
17453 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17454 PyObject *resultobj = NULL;
17455 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17456 bool result;
17457 PyObject * obj0 = 0 ;
17458 char *kwnames[] = {
17459 (char *) "self", NULL
17460 };
17461
17462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
17463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17464 if (SWIG_arg_fail(1)) SWIG_fail;
17465 {
17466 PyThreadState* __tstate = wxPyBeginAllowThreads();
17467 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
17468
17469 wxPyEndAllowThreads(__tstate);
17470 if (PyErr_Occurred()) SWIG_fail;
17471 }
17472 {
17473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17474 }
17475 return resultobj;
17476 fail:
17477 return NULL;
17478 }
17479
17480
17481 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17482 PyObject *resultobj = NULL;
17483 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17484 bool result;
17485 PyObject * obj0 = 0 ;
17486 char *kwnames[] = {
17487 (char *) "self", NULL
17488 };
17489
17490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
17491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17492 if (SWIG_arg_fail(1)) SWIG_fail;
17493 {
17494 PyThreadState* __tstate = wxPyBeginAllowThreads();
17495 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
17496
17497 wxPyEndAllowThreads(__tstate);
17498 if (PyErr_Occurred()) SWIG_fail;
17499 }
17500 {
17501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17502 }
17503 return resultobj;
17504 fail:
17505 return NULL;
17506 }
17507
17508
17509 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17510 PyObject *resultobj = NULL;
17511 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17512 bool result;
17513 PyObject * obj0 = 0 ;
17514 char *kwnames[] = {
17515 (char *) "self", NULL
17516 };
17517
17518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
17519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17520 if (SWIG_arg_fail(1)) SWIG_fail;
17521 {
17522 PyThreadState* __tstate = wxPyBeginAllowThreads();
17523 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
17524
17525 wxPyEndAllowThreads(__tstate);
17526 if (PyErr_Occurred()) SWIG_fail;
17527 }
17528 {
17529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17530 }
17531 return resultobj;
17532 fail:
17533 return NULL;
17534 }
17535
17536
17537 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17538 PyObject *resultobj = NULL;
17539 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17540 bool result;
17541 PyObject * obj0 = 0 ;
17542 char *kwnames[] = {
17543 (char *) "self", NULL
17544 };
17545
17546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
17547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17548 if (SWIG_arg_fail(1)) SWIG_fail;
17549 {
17550 PyThreadState* __tstate = wxPyBeginAllowThreads();
17551 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
17552
17553 wxPyEndAllowThreads(__tstate);
17554 if (PyErr_Occurred()) SWIG_fail;
17555 }
17556 {
17557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17558 }
17559 return resultobj;
17560 fail:
17561 return NULL;
17562 }
17563
17564
17565 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17566 PyObject *resultobj = NULL;
17567 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17568 bool result;
17569 PyObject * obj0 = 0 ;
17570 char *kwnames[] = {
17571 (char *) "self", NULL
17572 };
17573
17574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
17575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17576 if (SWIG_arg_fail(1)) SWIG_fail;
17577 {
17578 PyThreadState* __tstate = wxPyBeginAllowThreads();
17579 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
17580
17581 wxPyEndAllowThreads(__tstate);
17582 if (PyErr_Occurred()) SWIG_fail;
17583 }
17584 {
17585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17586 }
17587 return resultobj;
17588 fail:
17589 return NULL;
17590 }
17591
17592
17593 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
17594 PyObject *resultobj = NULL;
17595 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17596 bool result;
17597 PyObject * obj0 = 0 ;
17598 char *kwnames[] = {
17599 (char *) "self", NULL
17600 };
17601
17602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
17603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17604 if (SWIG_arg_fail(1)) SWIG_fail;
17605 {
17606 PyThreadState* __tstate = wxPyBeginAllowThreads();
17607 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
17608
17609 wxPyEndAllowThreads(__tstate);
17610 if (PyErr_Occurred()) SWIG_fail;
17611 }
17612 {
17613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17614 }
17615 return resultobj;
17616 fail:
17617 return NULL;
17618 }
17619
17620
17621 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
17622 PyObject *resultobj = NULL;
17623 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17624 bool result;
17625 PyObject * obj0 = 0 ;
17626 char *kwnames[] = {
17627 (char *) "self", NULL
17628 };
17629
17630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
17631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17632 if (SWIG_arg_fail(1)) SWIG_fail;
17633 {
17634 PyThreadState* __tstate = wxPyBeginAllowThreads();
17635 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
17636
17637 wxPyEndAllowThreads(__tstate);
17638 if (PyErr_Occurred()) SWIG_fail;
17639 }
17640 {
17641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17642 }
17643 return resultobj;
17644 fail:
17645 return NULL;
17646 }
17647
17648
17649 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
17650 PyObject *resultobj = NULL;
17651 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17652 bool result;
17653 PyObject * obj0 = 0 ;
17654 char *kwnames[] = {
17655 (char *) "self", NULL
17656 };
17657
17658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
17659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17660 if (SWIG_arg_fail(1)) SWIG_fail;
17661 {
17662 PyThreadState* __tstate = wxPyBeginAllowThreads();
17663 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
17664
17665 wxPyEndAllowThreads(__tstate);
17666 if (PyErr_Occurred()) SWIG_fail;
17667 }
17668 {
17669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17670 }
17671 return resultobj;
17672 fail:
17673 return NULL;
17674 }
17675
17676
17677 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
17678 PyObject *resultobj = NULL;
17679 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17680 bool result;
17681 PyObject * obj0 = 0 ;
17682 char *kwnames[] = {
17683 (char *) "self", NULL
17684 };
17685
17686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
17687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17688 if (SWIG_arg_fail(1)) SWIG_fail;
17689 {
17690 PyThreadState* __tstate = wxPyBeginAllowThreads();
17691 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
17692
17693 wxPyEndAllowThreads(__tstate);
17694 if (PyErr_Occurred()) SWIG_fail;
17695 }
17696 {
17697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17698 }
17699 return resultobj;
17700 fail:
17701 return NULL;
17702 }
17703
17704
17705 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
17706 PyObject *resultobj = NULL;
17707 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17708 bool result;
17709 PyObject * obj0 = 0 ;
17710 char *kwnames[] = {
17711 (char *) "self", NULL
17712 };
17713
17714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
17715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17716 if (SWIG_arg_fail(1)) SWIG_fail;
17717 {
17718 PyThreadState* __tstate = wxPyBeginAllowThreads();
17719 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
17720
17721 wxPyEndAllowThreads(__tstate);
17722 if (PyErr_Occurred()) SWIG_fail;
17723 }
17724 {
17725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17726 }
17727 return resultobj;
17728 fail:
17729 return NULL;
17730 }
17731
17732
17733 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17734 PyObject *resultobj = NULL;
17735 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17736 bool result;
17737 PyObject * obj0 = 0 ;
17738 char *kwnames[] = {
17739 (char *) "self", NULL
17740 };
17741
17742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
17743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17744 if (SWIG_arg_fail(1)) SWIG_fail;
17745 {
17746 PyThreadState* __tstate = wxPyBeginAllowThreads();
17747 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
17748
17749 wxPyEndAllowThreads(__tstate);
17750 if (PyErr_Occurred()) SWIG_fail;
17751 }
17752 {
17753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17754 }
17755 return resultobj;
17756 fail:
17757 return NULL;
17758 }
17759
17760
17761 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17762 PyObject *resultobj = NULL;
17763 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17764 bool result;
17765 PyObject * obj0 = 0 ;
17766 char *kwnames[] = {
17767 (char *) "self", NULL
17768 };
17769
17770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17772 if (SWIG_arg_fail(1)) SWIG_fail;
17773 {
17774 PyThreadState* __tstate = wxPyBeginAllowThreads();
17775 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17776
17777 wxPyEndAllowThreads(__tstate);
17778 if (PyErr_Occurred()) SWIG_fail;
17779 }
17780 {
17781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17782 }
17783 return resultobj;
17784 fail:
17785 return NULL;
17786 }
17787
17788
17789 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17790 PyObject *resultobj = NULL;
17791 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17792 bool result;
17793 PyObject * obj0 = 0 ;
17794 char *kwnames[] = {
17795 (char *) "self", NULL
17796 };
17797
17798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17800 if (SWIG_arg_fail(1)) SWIG_fail;
17801 {
17802 PyThreadState* __tstate = wxPyBeginAllowThreads();
17803 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17804
17805 wxPyEndAllowThreads(__tstate);
17806 if (PyErr_Occurred()) SWIG_fail;
17807 }
17808 {
17809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17810 }
17811 return resultobj;
17812 fail:
17813 return NULL;
17814 }
17815
17816
17817 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17818 PyObject *resultobj = NULL;
17819 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17820 bool result;
17821 PyObject * obj0 = 0 ;
17822 char *kwnames[] = {
17823 (char *) "self", NULL
17824 };
17825
17826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17828 if (SWIG_arg_fail(1)) SWIG_fail;
17829 {
17830 PyThreadState* __tstate = wxPyBeginAllowThreads();
17831 result = (bool)(arg1)->LeftIsDown();
17832
17833 wxPyEndAllowThreads(__tstate);
17834 if (PyErr_Occurred()) SWIG_fail;
17835 }
17836 {
17837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17838 }
17839 return resultobj;
17840 fail:
17841 return NULL;
17842 }
17843
17844
17845 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17846 PyObject *resultobj = NULL;
17847 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17848 bool result;
17849 PyObject * obj0 = 0 ;
17850 char *kwnames[] = {
17851 (char *) "self", NULL
17852 };
17853
17854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17856 if (SWIG_arg_fail(1)) SWIG_fail;
17857 {
17858 PyThreadState* __tstate = wxPyBeginAllowThreads();
17859 result = (bool)(arg1)->MiddleIsDown();
17860
17861 wxPyEndAllowThreads(__tstate);
17862 if (PyErr_Occurred()) SWIG_fail;
17863 }
17864 {
17865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17866 }
17867 return resultobj;
17868 fail:
17869 return NULL;
17870 }
17871
17872
17873 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17874 PyObject *resultobj = NULL;
17875 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17876 bool result;
17877 PyObject * obj0 = 0 ;
17878 char *kwnames[] = {
17879 (char *) "self", NULL
17880 };
17881
17882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17884 if (SWIG_arg_fail(1)) SWIG_fail;
17885 {
17886 PyThreadState* __tstate = wxPyBeginAllowThreads();
17887 result = (bool)(arg1)->RightIsDown();
17888
17889 wxPyEndAllowThreads(__tstate);
17890 if (PyErr_Occurred()) SWIG_fail;
17891 }
17892 {
17893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17894 }
17895 return resultobj;
17896 fail:
17897 return NULL;
17898 }
17899
17900
17901 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17902 PyObject *resultobj = NULL;
17903 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17904 bool result;
17905 PyObject * obj0 = 0 ;
17906 char *kwnames[] = {
17907 (char *) "self", NULL
17908 };
17909
17910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17912 if (SWIG_arg_fail(1)) SWIG_fail;
17913 {
17914 PyThreadState* __tstate = wxPyBeginAllowThreads();
17915 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17916
17917 wxPyEndAllowThreads(__tstate);
17918 if (PyErr_Occurred()) SWIG_fail;
17919 }
17920 {
17921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17922 }
17923 return resultobj;
17924 fail:
17925 return NULL;
17926 }
17927
17928
17929 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17930 PyObject *resultobj = NULL;
17931 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17932 bool result;
17933 PyObject * obj0 = 0 ;
17934 char *kwnames[] = {
17935 (char *) "self", NULL
17936 };
17937
17938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17940 if (SWIG_arg_fail(1)) SWIG_fail;
17941 {
17942 PyThreadState* __tstate = wxPyBeginAllowThreads();
17943 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17944
17945 wxPyEndAllowThreads(__tstate);
17946 if (PyErr_Occurred()) SWIG_fail;
17947 }
17948 {
17949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17950 }
17951 return resultobj;
17952 fail:
17953 return NULL;
17954 }
17955
17956
17957 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17958 PyObject *resultobj = NULL;
17959 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17960 bool result;
17961 PyObject * obj0 = 0 ;
17962 char *kwnames[] = {
17963 (char *) "self", NULL
17964 };
17965
17966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17968 if (SWIG_arg_fail(1)) SWIG_fail;
17969 {
17970 PyThreadState* __tstate = wxPyBeginAllowThreads();
17971 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17972
17973 wxPyEndAllowThreads(__tstate);
17974 if (PyErr_Occurred()) SWIG_fail;
17975 }
17976 {
17977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17978 }
17979 return resultobj;
17980 fail:
17981 return NULL;
17982 }
17983
17984
17985 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17986 PyObject *resultobj = NULL;
17987 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17988 bool result;
17989 PyObject * obj0 = 0 ;
17990 char *kwnames[] = {
17991 (char *) "self", NULL
17992 };
17993
17994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17996 if (SWIG_arg_fail(1)) SWIG_fail;
17997 {
17998 PyThreadState* __tstate = wxPyBeginAllowThreads();
17999 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
18000
18001 wxPyEndAllowThreads(__tstate);
18002 if (PyErr_Occurred()) SWIG_fail;
18003 }
18004 {
18005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18006 }
18007 return resultobj;
18008 fail:
18009 return NULL;
18010 }
18011
18012
18013 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18014 PyObject *resultobj = NULL;
18015 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18016 wxPoint result;
18017 PyObject * obj0 = 0 ;
18018 char *kwnames[] = {
18019 (char *) "self", NULL
18020 };
18021
18022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
18023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18024 if (SWIG_arg_fail(1)) SWIG_fail;
18025 {
18026 PyThreadState* __tstate = wxPyBeginAllowThreads();
18027 result = (arg1)->GetPosition();
18028
18029 wxPyEndAllowThreads(__tstate);
18030 if (PyErr_Occurred()) SWIG_fail;
18031 }
18032 {
18033 wxPoint * resultptr;
18034 resultptr = new wxPoint(static_cast<wxPoint & >(result));
18035 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18036 }
18037 return resultobj;
18038 fail:
18039 return NULL;
18040 }
18041
18042
18043 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18044 PyObject *resultobj = NULL;
18045 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18046 long *arg2 = (long *) 0 ;
18047 long *arg3 = (long *) 0 ;
18048 long temp2 ;
18049 int res2 = 0 ;
18050 long temp3 ;
18051 int res3 = 0 ;
18052 PyObject * obj0 = 0 ;
18053 char *kwnames[] = {
18054 (char *) "self", NULL
18055 };
18056
18057 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18058 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18061 if (SWIG_arg_fail(1)) SWIG_fail;
18062 {
18063 PyThreadState* __tstate = wxPyBeginAllowThreads();
18064 (arg1)->GetPosition(arg2,arg3);
18065
18066 wxPyEndAllowThreads(__tstate);
18067 if (PyErr_Occurred()) SWIG_fail;
18068 }
18069 Py_INCREF(Py_None); resultobj = Py_None;
18070 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18071 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18072 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18073 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18074 return resultobj;
18075 fail:
18076 return NULL;
18077 }
18078
18079
18080 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18081 PyObject *resultobj = NULL;
18082 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18083 wxDC *arg2 = 0 ;
18084 wxPoint result;
18085 PyObject * obj0 = 0 ;
18086 PyObject * obj1 = 0 ;
18087 char *kwnames[] = {
18088 (char *) "self",(char *) "dc", NULL
18089 };
18090
18091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
18092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18093 if (SWIG_arg_fail(1)) SWIG_fail;
18094 {
18095 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
18096 if (SWIG_arg_fail(2)) SWIG_fail;
18097 if (arg2 == NULL) {
18098 SWIG_null_ref("wxDC");
18099 }
18100 if (SWIG_arg_fail(2)) SWIG_fail;
18101 }
18102 {
18103 PyThreadState* __tstate = wxPyBeginAllowThreads();
18104 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
18105
18106 wxPyEndAllowThreads(__tstate);
18107 if (PyErr_Occurred()) SWIG_fail;
18108 }
18109 {
18110 wxPoint * resultptr;
18111 resultptr = new wxPoint(static_cast<wxPoint & >(result));
18112 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18113 }
18114 return resultobj;
18115 fail:
18116 return NULL;
18117 }
18118
18119
18120 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18121 PyObject *resultobj = NULL;
18122 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18123 int result;
18124 PyObject * obj0 = 0 ;
18125 char *kwnames[] = {
18126 (char *) "self", NULL
18127 };
18128
18129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
18130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18131 if (SWIG_arg_fail(1)) SWIG_fail;
18132 {
18133 PyThreadState* __tstate = wxPyBeginAllowThreads();
18134 result = (int)((wxMouseEvent const *)arg1)->GetX();
18135
18136 wxPyEndAllowThreads(__tstate);
18137 if (PyErr_Occurred()) SWIG_fail;
18138 }
18139 {
18140 resultobj = SWIG_From_int(static_cast<int >(result));
18141 }
18142 return resultobj;
18143 fail:
18144 return NULL;
18145 }
18146
18147
18148 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18149 PyObject *resultobj = NULL;
18150 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18151 int result;
18152 PyObject * obj0 = 0 ;
18153 char *kwnames[] = {
18154 (char *) "self", NULL
18155 };
18156
18157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
18158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18159 if (SWIG_arg_fail(1)) SWIG_fail;
18160 {
18161 PyThreadState* __tstate = wxPyBeginAllowThreads();
18162 result = (int)((wxMouseEvent const *)arg1)->GetY();
18163
18164 wxPyEndAllowThreads(__tstate);
18165 if (PyErr_Occurred()) SWIG_fail;
18166 }
18167 {
18168 resultobj = SWIG_From_int(static_cast<int >(result));
18169 }
18170 return resultobj;
18171 fail:
18172 return NULL;
18173 }
18174
18175
18176 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
18177 PyObject *resultobj = NULL;
18178 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18179 int result;
18180 PyObject * obj0 = 0 ;
18181 char *kwnames[] = {
18182 (char *) "self", NULL
18183 };
18184
18185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
18186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18187 if (SWIG_arg_fail(1)) SWIG_fail;
18188 {
18189 PyThreadState* __tstate = wxPyBeginAllowThreads();
18190 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
18191
18192 wxPyEndAllowThreads(__tstate);
18193 if (PyErr_Occurred()) SWIG_fail;
18194 }
18195 {
18196 resultobj = SWIG_From_int(static_cast<int >(result));
18197 }
18198 return resultobj;
18199 fail:
18200 return NULL;
18201 }
18202
18203
18204 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
18205 PyObject *resultobj = NULL;
18206 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18207 int result;
18208 PyObject * obj0 = 0 ;
18209 char *kwnames[] = {
18210 (char *) "self", NULL
18211 };
18212
18213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
18214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18215 if (SWIG_arg_fail(1)) SWIG_fail;
18216 {
18217 PyThreadState* __tstate = wxPyBeginAllowThreads();
18218 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
18219
18220 wxPyEndAllowThreads(__tstate);
18221 if (PyErr_Occurred()) SWIG_fail;
18222 }
18223 {
18224 resultobj = SWIG_From_int(static_cast<int >(result));
18225 }
18226 return resultobj;
18227 fail:
18228 return NULL;
18229 }
18230
18231
18232 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
18233 PyObject *resultobj = NULL;
18234 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18235 int result;
18236 PyObject * obj0 = 0 ;
18237 char *kwnames[] = {
18238 (char *) "self", NULL
18239 };
18240
18241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
18242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18243 if (SWIG_arg_fail(1)) SWIG_fail;
18244 {
18245 PyThreadState* __tstate = wxPyBeginAllowThreads();
18246 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
18247
18248 wxPyEndAllowThreads(__tstate);
18249 if (PyErr_Occurred()) SWIG_fail;
18250 }
18251 {
18252 resultobj = SWIG_From_int(static_cast<int >(result));
18253 }
18254 return resultobj;
18255 fail:
18256 return NULL;
18257 }
18258
18259
18260 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
18261 PyObject *resultobj = NULL;
18262 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18263 bool result;
18264 PyObject * obj0 = 0 ;
18265 char *kwnames[] = {
18266 (char *) "self", NULL
18267 };
18268
18269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
18270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18271 if (SWIG_arg_fail(1)) SWIG_fail;
18272 {
18273 PyThreadState* __tstate = wxPyBeginAllowThreads();
18274 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
18275
18276 wxPyEndAllowThreads(__tstate);
18277 if (PyErr_Occurred()) SWIG_fail;
18278 }
18279 {
18280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18281 }
18282 return resultobj;
18283 fail:
18284 return NULL;
18285 }
18286
18287
18288 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18289 PyObject *resultobj = NULL;
18290 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18291 int arg2 ;
18292 PyObject * obj0 = 0 ;
18293 PyObject * obj1 = 0 ;
18294 char *kwnames[] = {
18295 (char *) "self",(char *) "m_x", NULL
18296 };
18297
18298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18300 if (SWIG_arg_fail(1)) SWIG_fail;
18301 {
18302 arg2 = static_cast<int >(SWIG_As_int(obj1));
18303 if (SWIG_arg_fail(2)) SWIG_fail;
18304 }
18305 if (arg1) (arg1)->m_x = arg2;
18306
18307 Py_INCREF(Py_None); resultobj = Py_None;
18308 return resultobj;
18309 fail:
18310 return NULL;
18311 }
18312
18313
18314 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18315 PyObject *resultobj = NULL;
18316 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18317 int result;
18318 PyObject * obj0 = 0 ;
18319 char *kwnames[] = {
18320 (char *) "self", NULL
18321 };
18322
18323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
18324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18325 if (SWIG_arg_fail(1)) SWIG_fail;
18326 result = (int) ((arg1)->m_x);
18327
18328 {
18329 resultobj = SWIG_From_int(static_cast<int >(result));
18330 }
18331 return resultobj;
18332 fail:
18333 return NULL;
18334 }
18335
18336
18337 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18338 PyObject *resultobj = NULL;
18339 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18340 int arg2 ;
18341 PyObject * obj0 = 0 ;
18342 PyObject * obj1 = 0 ;
18343 char *kwnames[] = {
18344 (char *) "self",(char *) "m_y", NULL
18345 };
18346
18347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18349 if (SWIG_arg_fail(1)) SWIG_fail;
18350 {
18351 arg2 = static_cast<int >(SWIG_As_int(obj1));
18352 if (SWIG_arg_fail(2)) SWIG_fail;
18353 }
18354 if (arg1) (arg1)->m_y = arg2;
18355
18356 Py_INCREF(Py_None); resultobj = Py_None;
18357 return resultobj;
18358 fail:
18359 return NULL;
18360 }
18361
18362
18363 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18364 PyObject *resultobj = NULL;
18365 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18366 int result;
18367 PyObject * obj0 = 0 ;
18368 char *kwnames[] = {
18369 (char *) "self", NULL
18370 };
18371
18372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
18373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18374 if (SWIG_arg_fail(1)) SWIG_fail;
18375 result = (int) ((arg1)->m_y);
18376
18377 {
18378 resultobj = SWIG_From_int(static_cast<int >(result));
18379 }
18380 return resultobj;
18381 fail:
18382 return NULL;
18383 }
18384
18385
18386 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18387 PyObject *resultobj = NULL;
18388 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18389 bool arg2 ;
18390 PyObject * obj0 = 0 ;
18391 PyObject * obj1 = 0 ;
18392 char *kwnames[] = {
18393 (char *) "self",(char *) "m_leftDown", NULL
18394 };
18395
18396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
18397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18398 if (SWIG_arg_fail(1)) SWIG_fail;
18399 {
18400 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18401 if (SWIG_arg_fail(2)) SWIG_fail;
18402 }
18403 if (arg1) (arg1)->m_leftDown = arg2;
18404
18405 Py_INCREF(Py_None); resultobj = Py_None;
18406 return resultobj;
18407 fail:
18408 return NULL;
18409 }
18410
18411
18412 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18413 PyObject *resultobj = NULL;
18414 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18415 bool result;
18416 PyObject * obj0 = 0 ;
18417 char *kwnames[] = {
18418 (char *) "self", NULL
18419 };
18420
18421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
18422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18423 if (SWIG_arg_fail(1)) SWIG_fail;
18424 result = (bool) ((arg1)->m_leftDown);
18425
18426 {
18427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18428 }
18429 return resultobj;
18430 fail:
18431 return NULL;
18432 }
18433
18434
18435 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18436 PyObject *resultobj = NULL;
18437 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18438 bool arg2 ;
18439 PyObject * obj0 = 0 ;
18440 PyObject * obj1 = 0 ;
18441 char *kwnames[] = {
18442 (char *) "self",(char *) "m_middleDown", NULL
18443 };
18444
18445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
18446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18447 if (SWIG_arg_fail(1)) SWIG_fail;
18448 {
18449 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18450 if (SWIG_arg_fail(2)) SWIG_fail;
18451 }
18452 if (arg1) (arg1)->m_middleDown = arg2;
18453
18454 Py_INCREF(Py_None); resultobj = Py_None;
18455 return resultobj;
18456 fail:
18457 return NULL;
18458 }
18459
18460
18461 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18462 PyObject *resultobj = NULL;
18463 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18464 bool result;
18465 PyObject * obj0 = 0 ;
18466 char *kwnames[] = {
18467 (char *) "self", NULL
18468 };
18469
18470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
18471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18472 if (SWIG_arg_fail(1)) SWIG_fail;
18473 result = (bool) ((arg1)->m_middleDown);
18474
18475 {
18476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18477 }
18478 return resultobj;
18479 fail:
18480 return NULL;
18481 }
18482
18483
18484 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18485 PyObject *resultobj = NULL;
18486 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18487 bool arg2 ;
18488 PyObject * obj0 = 0 ;
18489 PyObject * obj1 = 0 ;
18490 char *kwnames[] = {
18491 (char *) "self",(char *) "m_rightDown", NULL
18492 };
18493
18494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
18495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18496 if (SWIG_arg_fail(1)) SWIG_fail;
18497 {
18498 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18499 if (SWIG_arg_fail(2)) SWIG_fail;
18500 }
18501 if (arg1) (arg1)->m_rightDown = arg2;
18502
18503 Py_INCREF(Py_None); resultobj = Py_None;
18504 return resultobj;
18505 fail:
18506 return NULL;
18507 }
18508
18509
18510 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18511 PyObject *resultobj = NULL;
18512 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18513 bool result;
18514 PyObject * obj0 = 0 ;
18515 char *kwnames[] = {
18516 (char *) "self", NULL
18517 };
18518
18519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
18520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18521 if (SWIG_arg_fail(1)) SWIG_fail;
18522 result = (bool) ((arg1)->m_rightDown);
18523
18524 {
18525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18526 }
18527 return resultobj;
18528 fail:
18529 return NULL;
18530 }
18531
18532
18533 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18534 PyObject *resultobj = NULL;
18535 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18536 bool arg2 ;
18537 PyObject * obj0 = 0 ;
18538 PyObject * obj1 = 0 ;
18539 char *kwnames[] = {
18540 (char *) "self",(char *) "m_controlDown", NULL
18541 };
18542
18543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18545 if (SWIG_arg_fail(1)) SWIG_fail;
18546 {
18547 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18548 if (SWIG_arg_fail(2)) SWIG_fail;
18549 }
18550 if (arg1) (arg1)->m_controlDown = arg2;
18551
18552 Py_INCREF(Py_None); resultobj = Py_None;
18553 return resultobj;
18554 fail:
18555 return NULL;
18556 }
18557
18558
18559 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18560 PyObject *resultobj = NULL;
18561 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18562 bool result;
18563 PyObject * obj0 = 0 ;
18564 char *kwnames[] = {
18565 (char *) "self", NULL
18566 };
18567
18568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18570 if (SWIG_arg_fail(1)) SWIG_fail;
18571 result = (bool) ((arg1)->m_controlDown);
18572
18573 {
18574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18575 }
18576 return resultobj;
18577 fail:
18578 return NULL;
18579 }
18580
18581
18582 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18583 PyObject *resultobj = NULL;
18584 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18585 bool arg2 ;
18586 PyObject * obj0 = 0 ;
18587 PyObject * obj1 = 0 ;
18588 char *kwnames[] = {
18589 (char *) "self",(char *) "m_shiftDown", NULL
18590 };
18591
18592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18594 if (SWIG_arg_fail(1)) SWIG_fail;
18595 {
18596 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18597 if (SWIG_arg_fail(2)) SWIG_fail;
18598 }
18599 if (arg1) (arg1)->m_shiftDown = arg2;
18600
18601 Py_INCREF(Py_None); resultobj = Py_None;
18602 return resultobj;
18603 fail:
18604 return NULL;
18605 }
18606
18607
18608 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18609 PyObject *resultobj = NULL;
18610 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18611 bool result;
18612 PyObject * obj0 = 0 ;
18613 char *kwnames[] = {
18614 (char *) "self", NULL
18615 };
18616
18617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18619 if (SWIG_arg_fail(1)) SWIG_fail;
18620 result = (bool) ((arg1)->m_shiftDown);
18621
18622 {
18623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18624 }
18625 return resultobj;
18626 fail:
18627 return NULL;
18628 }
18629
18630
18631 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18632 PyObject *resultobj = NULL;
18633 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18634 bool arg2 ;
18635 PyObject * obj0 = 0 ;
18636 PyObject * obj1 = 0 ;
18637 char *kwnames[] = {
18638 (char *) "self",(char *) "m_altDown", NULL
18639 };
18640
18641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18643 if (SWIG_arg_fail(1)) SWIG_fail;
18644 {
18645 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18646 if (SWIG_arg_fail(2)) SWIG_fail;
18647 }
18648 if (arg1) (arg1)->m_altDown = arg2;
18649
18650 Py_INCREF(Py_None); resultobj = Py_None;
18651 return resultobj;
18652 fail:
18653 return NULL;
18654 }
18655
18656
18657 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18658 PyObject *resultobj = NULL;
18659 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18660 bool result;
18661 PyObject * obj0 = 0 ;
18662 char *kwnames[] = {
18663 (char *) "self", NULL
18664 };
18665
18666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18668 if (SWIG_arg_fail(1)) SWIG_fail;
18669 result = (bool) ((arg1)->m_altDown);
18670
18671 {
18672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18673 }
18674 return resultobj;
18675 fail:
18676 return NULL;
18677 }
18678
18679
18680 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18681 PyObject *resultobj = NULL;
18682 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18683 bool arg2 ;
18684 PyObject * obj0 = 0 ;
18685 PyObject * obj1 = 0 ;
18686 char *kwnames[] = {
18687 (char *) "self",(char *) "m_metaDown", NULL
18688 };
18689
18690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18692 if (SWIG_arg_fail(1)) SWIG_fail;
18693 {
18694 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
18695 if (SWIG_arg_fail(2)) SWIG_fail;
18696 }
18697 if (arg1) (arg1)->m_metaDown = arg2;
18698
18699 Py_INCREF(Py_None); resultobj = Py_None;
18700 return resultobj;
18701 fail:
18702 return NULL;
18703 }
18704
18705
18706 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18707 PyObject *resultobj = NULL;
18708 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18709 bool result;
18710 PyObject * obj0 = 0 ;
18711 char *kwnames[] = {
18712 (char *) "self", NULL
18713 };
18714
18715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18717 if (SWIG_arg_fail(1)) SWIG_fail;
18718 result = (bool) ((arg1)->m_metaDown);
18719
18720 {
18721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18722 }
18723 return resultobj;
18724 fail:
18725 return NULL;
18726 }
18727
18728
18729 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
18730 PyObject *resultobj = NULL;
18731 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18732 int arg2 ;
18733 PyObject * obj0 = 0 ;
18734 PyObject * obj1 = 0 ;
18735 char *kwnames[] = {
18736 (char *) "self",(char *) "m_wheelRotation", NULL
18737 };
18738
18739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
18740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18741 if (SWIG_arg_fail(1)) SWIG_fail;
18742 {
18743 arg2 = static_cast<int >(SWIG_As_int(obj1));
18744 if (SWIG_arg_fail(2)) SWIG_fail;
18745 }
18746 if (arg1) (arg1)->m_wheelRotation = arg2;
18747
18748 Py_INCREF(Py_None); resultobj = Py_None;
18749 return resultobj;
18750 fail:
18751 return NULL;
18752 }
18753
18754
18755 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
18756 PyObject *resultobj = NULL;
18757 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18758 int result;
18759 PyObject * obj0 = 0 ;
18760 char *kwnames[] = {
18761 (char *) "self", NULL
18762 };
18763
18764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18766 if (SWIG_arg_fail(1)) SWIG_fail;
18767 result = (int) ((arg1)->m_wheelRotation);
18768
18769 {
18770 resultobj = SWIG_From_int(static_cast<int >(result));
18771 }
18772 return resultobj;
18773 fail:
18774 return NULL;
18775 }
18776
18777
18778 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18779 PyObject *resultobj = NULL;
18780 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18781 int arg2 ;
18782 PyObject * obj0 = 0 ;
18783 PyObject * obj1 = 0 ;
18784 char *kwnames[] = {
18785 (char *) "self",(char *) "m_wheelDelta", NULL
18786 };
18787
18788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18790 if (SWIG_arg_fail(1)) SWIG_fail;
18791 {
18792 arg2 = static_cast<int >(SWIG_As_int(obj1));
18793 if (SWIG_arg_fail(2)) SWIG_fail;
18794 }
18795 if (arg1) (arg1)->m_wheelDelta = arg2;
18796
18797 Py_INCREF(Py_None); resultobj = Py_None;
18798 return resultobj;
18799 fail:
18800 return NULL;
18801 }
18802
18803
18804 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18805 PyObject *resultobj = NULL;
18806 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18807 int result;
18808 PyObject * obj0 = 0 ;
18809 char *kwnames[] = {
18810 (char *) "self", NULL
18811 };
18812
18813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18815 if (SWIG_arg_fail(1)) SWIG_fail;
18816 result = (int) ((arg1)->m_wheelDelta);
18817
18818 {
18819 resultobj = SWIG_From_int(static_cast<int >(result));
18820 }
18821 return resultobj;
18822 fail:
18823 return NULL;
18824 }
18825
18826
18827 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18828 PyObject *resultobj = NULL;
18829 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18830 int arg2 ;
18831 PyObject * obj0 = 0 ;
18832 PyObject * obj1 = 0 ;
18833 char *kwnames[] = {
18834 (char *) "self",(char *) "m_linesPerAction", NULL
18835 };
18836
18837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18839 if (SWIG_arg_fail(1)) SWIG_fail;
18840 {
18841 arg2 = static_cast<int >(SWIG_As_int(obj1));
18842 if (SWIG_arg_fail(2)) SWIG_fail;
18843 }
18844 if (arg1) (arg1)->m_linesPerAction = arg2;
18845
18846 Py_INCREF(Py_None); resultobj = Py_None;
18847 return resultobj;
18848 fail:
18849 return NULL;
18850 }
18851
18852
18853 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18854 PyObject *resultobj = NULL;
18855 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18856 int result;
18857 PyObject * obj0 = 0 ;
18858 char *kwnames[] = {
18859 (char *) "self", NULL
18860 };
18861
18862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18864 if (SWIG_arg_fail(1)) SWIG_fail;
18865 result = (int) ((arg1)->m_linesPerAction);
18866
18867 {
18868 resultobj = SWIG_From_int(static_cast<int >(result));
18869 }
18870 return resultobj;
18871 fail:
18872 return NULL;
18873 }
18874
18875
18876 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18877 PyObject *obj;
18878 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18879 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18880 Py_INCREF(obj);
18881 return Py_BuildValue((char *)"");
18882 }
18883 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18884 PyObject *resultobj = NULL;
18885 int arg1 = (int) 0 ;
18886 int arg2 = (int) 0 ;
18887 wxSetCursorEvent *result;
18888 PyObject * obj0 = 0 ;
18889 PyObject * obj1 = 0 ;
18890 char *kwnames[] = {
18891 (char *) "x",(char *) "y", NULL
18892 };
18893
18894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18895 if (obj0) {
18896 {
18897 arg1 = static_cast<int >(SWIG_As_int(obj0));
18898 if (SWIG_arg_fail(1)) SWIG_fail;
18899 }
18900 }
18901 if (obj1) {
18902 {
18903 arg2 = static_cast<int >(SWIG_As_int(obj1));
18904 if (SWIG_arg_fail(2)) SWIG_fail;
18905 }
18906 }
18907 {
18908 PyThreadState* __tstate = wxPyBeginAllowThreads();
18909 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18910
18911 wxPyEndAllowThreads(__tstate);
18912 if (PyErr_Occurred()) SWIG_fail;
18913 }
18914 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18915 return resultobj;
18916 fail:
18917 return NULL;
18918 }
18919
18920
18921 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18922 PyObject *resultobj = NULL;
18923 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18924 int result;
18925 PyObject * obj0 = 0 ;
18926 char *kwnames[] = {
18927 (char *) "self", NULL
18928 };
18929
18930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18932 if (SWIG_arg_fail(1)) SWIG_fail;
18933 {
18934 PyThreadState* __tstate = wxPyBeginAllowThreads();
18935 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18936
18937 wxPyEndAllowThreads(__tstate);
18938 if (PyErr_Occurred()) SWIG_fail;
18939 }
18940 {
18941 resultobj = SWIG_From_int(static_cast<int >(result));
18942 }
18943 return resultobj;
18944 fail:
18945 return NULL;
18946 }
18947
18948
18949 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18950 PyObject *resultobj = NULL;
18951 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18952 int result;
18953 PyObject * obj0 = 0 ;
18954 char *kwnames[] = {
18955 (char *) "self", NULL
18956 };
18957
18958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18960 if (SWIG_arg_fail(1)) SWIG_fail;
18961 {
18962 PyThreadState* __tstate = wxPyBeginAllowThreads();
18963 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18964
18965 wxPyEndAllowThreads(__tstate);
18966 if (PyErr_Occurred()) SWIG_fail;
18967 }
18968 {
18969 resultobj = SWIG_From_int(static_cast<int >(result));
18970 }
18971 return resultobj;
18972 fail:
18973 return NULL;
18974 }
18975
18976
18977 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18978 PyObject *resultobj = NULL;
18979 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18980 wxCursor *arg2 = 0 ;
18981 PyObject * obj0 = 0 ;
18982 PyObject * obj1 = 0 ;
18983 char *kwnames[] = {
18984 (char *) "self",(char *) "cursor", NULL
18985 };
18986
18987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18989 if (SWIG_arg_fail(1)) SWIG_fail;
18990 {
18991 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18992 if (SWIG_arg_fail(2)) SWIG_fail;
18993 if (arg2 == NULL) {
18994 SWIG_null_ref("wxCursor");
18995 }
18996 if (SWIG_arg_fail(2)) SWIG_fail;
18997 }
18998 {
18999 PyThreadState* __tstate = wxPyBeginAllowThreads();
19000 (arg1)->SetCursor((wxCursor const &)*arg2);
19001
19002 wxPyEndAllowThreads(__tstate);
19003 if (PyErr_Occurred()) SWIG_fail;
19004 }
19005 Py_INCREF(Py_None); resultobj = Py_None;
19006 return resultobj;
19007 fail:
19008 return NULL;
19009 }
19010
19011
19012 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19013 PyObject *resultobj = NULL;
19014 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19015 wxCursor *result;
19016 PyObject * obj0 = 0 ;
19017 char *kwnames[] = {
19018 (char *) "self", NULL
19019 };
19020
19021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
19022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19023 if (SWIG_arg_fail(1)) SWIG_fail;
19024 {
19025 PyThreadState* __tstate = wxPyBeginAllowThreads();
19026 {
19027 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
19028 result = (wxCursor *) &_result_ref;
19029 }
19030
19031 wxPyEndAllowThreads(__tstate);
19032 if (PyErr_Occurred()) SWIG_fail;
19033 }
19034 {
19035 wxCursor* resultptr = new wxCursor(*result);
19036 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
19037 }
19038 return resultobj;
19039 fail:
19040 return NULL;
19041 }
19042
19043
19044 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
19045 PyObject *resultobj = NULL;
19046 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
19047 bool result;
19048 PyObject * obj0 = 0 ;
19049 char *kwnames[] = {
19050 (char *) "self", NULL
19051 };
19052
19053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
19054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
19055 if (SWIG_arg_fail(1)) SWIG_fail;
19056 {
19057 PyThreadState* __tstate = wxPyBeginAllowThreads();
19058 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
19059
19060 wxPyEndAllowThreads(__tstate);
19061 if (PyErr_Occurred()) SWIG_fail;
19062 }
19063 {
19064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19065 }
19066 return resultobj;
19067 fail:
19068 return NULL;
19069 }
19070
19071
19072 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
19073 PyObject *obj;
19074 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19075 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
19076 Py_INCREF(obj);
19077 return Py_BuildValue((char *)"");
19078 }
19079 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19080 PyObject *resultobj = NULL;
19081 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19082 wxKeyEvent *result;
19083 PyObject * obj0 = 0 ;
19084 char *kwnames[] = {
19085 (char *) "eventType", NULL
19086 };
19087
19088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
19089 if (obj0) {
19090 {
19091 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
19092 if (SWIG_arg_fail(1)) SWIG_fail;
19093 }
19094 }
19095 {
19096 PyThreadState* __tstate = wxPyBeginAllowThreads();
19097 result = (wxKeyEvent *)new wxKeyEvent(arg1);
19098
19099 wxPyEndAllowThreads(__tstate);
19100 if (PyErr_Occurred()) SWIG_fail;
19101 }
19102 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
19103 return resultobj;
19104 fail:
19105 return NULL;
19106 }
19107
19108
19109 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
19110 PyObject *resultobj = NULL;
19111 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19112 bool result;
19113 PyObject * obj0 = 0 ;
19114 char *kwnames[] = {
19115 (char *) "self", NULL
19116 };
19117
19118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
19119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19120 if (SWIG_arg_fail(1)) SWIG_fail;
19121 {
19122 PyThreadState* __tstate = wxPyBeginAllowThreads();
19123 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
19124
19125 wxPyEndAllowThreads(__tstate);
19126 if (PyErr_Occurred()) SWIG_fail;
19127 }
19128 {
19129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19130 }
19131 return resultobj;
19132 fail:
19133 return NULL;
19134 }
19135
19136
19137 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
19138 PyObject *resultobj = NULL;
19139 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19140 bool result;
19141 PyObject * obj0 = 0 ;
19142 char *kwnames[] = {
19143 (char *) "self", NULL
19144 };
19145
19146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
19147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19148 if (SWIG_arg_fail(1)) SWIG_fail;
19149 {
19150 PyThreadState* __tstate = wxPyBeginAllowThreads();
19151 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
19152
19153 wxPyEndAllowThreads(__tstate);
19154 if (PyErr_Occurred()) SWIG_fail;
19155 }
19156 {
19157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19158 }
19159 return resultobj;
19160 fail:
19161 return NULL;
19162 }
19163
19164
19165 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
19166 PyObject *resultobj = NULL;
19167 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19168 bool result;
19169 PyObject * obj0 = 0 ;
19170 char *kwnames[] = {
19171 (char *) "self", NULL
19172 };
19173
19174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
19175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19176 if (SWIG_arg_fail(1)) SWIG_fail;
19177 {
19178 PyThreadState* __tstate = wxPyBeginAllowThreads();
19179 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
19180
19181 wxPyEndAllowThreads(__tstate);
19182 if (PyErr_Occurred()) SWIG_fail;
19183 }
19184 {
19185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19186 }
19187 return resultobj;
19188 fail:
19189 return NULL;
19190 }
19191
19192
19193 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
19194 PyObject *resultobj = NULL;
19195 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19196 bool result;
19197 PyObject * obj0 = 0 ;
19198 char *kwnames[] = {
19199 (char *) "self", NULL
19200 };
19201
19202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
19203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19204 if (SWIG_arg_fail(1)) SWIG_fail;
19205 {
19206 PyThreadState* __tstate = wxPyBeginAllowThreads();
19207 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
19208
19209 wxPyEndAllowThreads(__tstate);
19210 if (PyErr_Occurred()) SWIG_fail;
19211 }
19212 {
19213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19214 }
19215 return resultobj;
19216 fail:
19217 return NULL;
19218 }
19219
19220
19221 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
19222 PyObject *resultobj = NULL;
19223 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19224 bool result;
19225 PyObject * obj0 = 0 ;
19226 char *kwnames[] = {
19227 (char *) "self", NULL
19228 };
19229
19230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
19231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19232 if (SWIG_arg_fail(1)) SWIG_fail;
19233 {
19234 PyThreadState* __tstate = wxPyBeginAllowThreads();
19235 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
19236
19237 wxPyEndAllowThreads(__tstate);
19238 if (PyErr_Occurred()) SWIG_fail;
19239 }
19240 {
19241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19242 }
19243 return resultobj;
19244 fail:
19245 return NULL;
19246 }
19247
19248
19249 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
19250 PyObject *resultobj = NULL;
19251 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19252 bool result;
19253 PyObject * obj0 = 0 ;
19254 char *kwnames[] = {
19255 (char *) "self", NULL
19256 };
19257
19258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
19259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19260 if (SWIG_arg_fail(1)) SWIG_fail;
19261 {
19262 PyThreadState* __tstate = wxPyBeginAllowThreads();
19263 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
19264
19265 wxPyEndAllowThreads(__tstate);
19266 if (PyErr_Occurred()) SWIG_fail;
19267 }
19268 {
19269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19270 }
19271 return resultobj;
19272 fail:
19273 return NULL;
19274 }
19275
19276
19277 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19278 PyObject *resultobj = NULL;
19279 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19280 int result;
19281 PyObject * obj0 = 0 ;
19282 char *kwnames[] = {
19283 (char *) "self", NULL
19284 };
19285
19286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
19287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19288 if (SWIG_arg_fail(1)) SWIG_fail;
19289 {
19290 PyThreadState* __tstate = wxPyBeginAllowThreads();
19291 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
19292
19293 wxPyEndAllowThreads(__tstate);
19294 if (PyErr_Occurred()) SWIG_fail;
19295 }
19296 {
19297 resultobj = SWIG_From_int(static_cast<int >(result));
19298 }
19299 return resultobj;
19300 fail:
19301 return NULL;
19302 }
19303
19304
19305 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
19306 PyObject *resultobj = NULL;
19307 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19308 int result;
19309 PyObject * obj0 = 0 ;
19310 char *kwnames[] = {
19311 (char *) "self", NULL
19312 };
19313
19314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
19315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19316 if (SWIG_arg_fail(1)) SWIG_fail;
19317 {
19318 PyThreadState* __tstate = wxPyBeginAllowThreads();
19319 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
19320
19321 wxPyEndAllowThreads(__tstate);
19322 if (PyErr_Occurred()) SWIG_fail;
19323 }
19324 {
19325 resultobj = SWIG_From_int(static_cast<int >(result));
19326 }
19327 return resultobj;
19328 fail:
19329 return NULL;
19330 }
19331
19332
19333 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19334 PyObject *resultobj = NULL;
19335 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19336 unsigned int result;
19337 PyObject * obj0 = 0 ;
19338 char *kwnames[] = {
19339 (char *) "self", NULL
19340 };
19341
19342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
19343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19344 if (SWIG_arg_fail(1)) SWIG_fail;
19345 {
19346 PyThreadState* __tstate = wxPyBeginAllowThreads();
19347 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
19348
19349 wxPyEndAllowThreads(__tstate);
19350 if (PyErr_Occurred()) SWIG_fail;
19351 }
19352 {
19353 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19354 }
19355 return resultobj;
19356 fail:
19357 return NULL;
19358 }
19359
19360
19361 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
19362 PyObject *resultobj = NULL;
19363 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19364 unsigned int result;
19365 PyObject * obj0 = 0 ;
19366 char *kwnames[] = {
19367 (char *) "self", NULL
19368 };
19369
19370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
19371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19372 if (SWIG_arg_fail(1)) SWIG_fail;
19373 {
19374 PyThreadState* __tstate = wxPyBeginAllowThreads();
19375 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
19376
19377 wxPyEndAllowThreads(__tstate);
19378 if (PyErr_Occurred()) SWIG_fail;
19379 }
19380 {
19381 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19382 }
19383 return resultobj;
19384 fail:
19385 return NULL;
19386 }
19387
19388
19389 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19390 PyObject *resultobj = NULL;
19391 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19392 wxPoint result;
19393 PyObject * obj0 = 0 ;
19394 char *kwnames[] = {
19395 (char *) "self", NULL
19396 };
19397
19398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
19399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19400 if (SWIG_arg_fail(1)) SWIG_fail;
19401 {
19402 PyThreadState* __tstate = wxPyBeginAllowThreads();
19403 result = (arg1)->GetPosition();
19404
19405 wxPyEndAllowThreads(__tstate);
19406 if (PyErr_Occurred()) SWIG_fail;
19407 }
19408 {
19409 wxPoint * resultptr;
19410 resultptr = new wxPoint(static_cast<wxPoint & >(result));
19411 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19412 }
19413 return resultobj;
19414 fail:
19415 return NULL;
19416 }
19417
19418
19419 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
19420 PyObject *resultobj = NULL;
19421 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19422 long *arg2 = (long *) 0 ;
19423 long *arg3 = (long *) 0 ;
19424 long temp2 ;
19425 int res2 = 0 ;
19426 long temp3 ;
19427 int res3 = 0 ;
19428 PyObject * obj0 = 0 ;
19429 char *kwnames[] = {
19430 (char *) "self", NULL
19431 };
19432
19433 arg2 = &temp2; res2 = SWIG_NEWOBJ;
19434 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
19436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19437 if (SWIG_arg_fail(1)) SWIG_fail;
19438 {
19439 PyThreadState* __tstate = wxPyBeginAllowThreads();
19440 (arg1)->GetPosition(arg2,arg3);
19441
19442 wxPyEndAllowThreads(__tstate);
19443 if (PyErr_Occurred()) SWIG_fail;
19444 }
19445 Py_INCREF(Py_None); resultobj = Py_None;
19446 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19447 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
19448 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19449 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
19450 return resultobj;
19451 fail:
19452 return NULL;
19453 }
19454
19455
19456 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
19457 PyObject *resultobj = NULL;
19458 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19459 int result;
19460 PyObject * obj0 = 0 ;
19461 char *kwnames[] = {
19462 (char *) "self", NULL
19463 };
19464
19465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
19466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19467 if (SWIG_arg_fail(1)) SWIG_fail;
19468 {
19469 PyThreadState* __tstate = wxPyBeginAllowThreads();
19470 result = (int)((wxKeyEvent const *)arg1)->GetX();
19471
19472 wxPyEndAllowThreads(__tstate);
19473 if (PyErr_Occurred()) SWIG_fail;
19474 }
19475 {
19476 resultobj = SWIG_From_int(static_cast<int >(result));
19477 }
19478 return resultobj;
19479 fail:
19480 return NULL;
19481 }
19482
19483
19484 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
19485 PyObject *resultobj = NULL;
19486 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19487 int result;
19488 PyObject * obj0 = 0 ;
19489 char *kwnames[] = {
19490 (char *) "self", NULL
19491 };
19492
19493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
19494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19495 if (SWIG_arg_fail(1)) SWIG_fail;
19496 {
19497 PyThreadState* __tstate = wxPyBeginAllowThreads();
19498 result = (int)((wxKeyEvent const *)arg1)->GetY();
19499
19500 wxPyEndAllowThreads(__tstate);
19501 if (PyErr_Occurred()) SWIG_fail;
19502 }
19503 {
19504 resultobj = SWIG_From_int(static_cast<int >(result));
19505 }
19506 return resultobj;
19507 fail:
19508 return NULL;
19509 }
19510
19511
19512 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
19513 PyObject *resultobj = NULL;
19514 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19515 int arg2 ;
19516 PyObject * obj0 = 0 ;
19517 PyObject * obj1 = 0 ;
19518 char *kwnames[] = {
19519 (char *) "self",(char *) "m_x", NULL
19520 };
19521
19522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
19523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19524 if (SWIG_arg_fail(1)) SWIG_fail;
19525 {
19526 arg2 = static_cast<int >(SWIG_As_int(obj1));
19527 if (SWIG_arg_fail(2)) SWIG_fail;
19528 }
19529 if (arg1) (arg1)->m_x = arg2;
19530
19531 Py_INCREF(Py_None); resultobj = Py_None;
19532 return resultobj;
19533 fail:
19534 return NULL;
19535 }
19536
19537
19538 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
19539 PyObject *resultobj = NULL;
19540 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19541 int result;
19542 PyObject * obj0 = 0 ;
19543 char *kwnames[] = {
19544 (char *) "self", NULL
19545 };
19546
19547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
19548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19549 if (SWIG_arg_fail(1)) SWIG_fail;
19550 result = (int) ((arg1)->m_x);
19551
19552 {
19553 resultobj = SWIG_From_int(static_cast<int >(result));
19554 }
19555 return resultobj;
19556 fail:
19557 return NULL;
19558 }
19559
19560
19561 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
19562 PyObject *resultobj = NULL;
19563 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19564 int arg2 ;
19565 PyObject * obj0 = 0 ;
19566 PyObject * obj1 = 0 ;
19567 char *kwnames[] = {
19568 (char *) "self",(char *) "m_y", NULL
19569 };
19570
19571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
19572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19573 if (SWIG_arg_fail(1)) SWIG_fail;
19574 {
19575 arg2 = static_cast<int >(SWIG_As_int(obj1));
19576 if (SWIG_arg_fail(2)) SWIG_fail;
19577 }
19578 if (arg1) (arg1)->m_y = arg2;
19579
19580 Py_INCREF(Py_None); resultobj = Py_None;
19581 return resultobj;
19582 fail:
19583 return NULL;
19584 }
19585
19586
19587 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
19588 PyObject *resultobj = NULL;
19589 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19590 int result;
19591 PyObject * obj0 = 0 ;
19592 char *kwnames[] = {
19593 (char *) "self", NULL
19594 };
19595
19596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
19597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19598 if (SWIG_arg_fail(1)) SWIG_fail;
19599 result = (int) ((arg1)->m_y);
19600
19601 {
19602 resultobj = SWIG_From_int(static_cast<int >(result));
19603 }
19604 return resultobj;
19605 fail:
19606 return NULL;
19607 }
19608
19609
19610 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19611 PyObject *resultobj = NULL;
19612 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19613 long arg2 ;
19614 PyObject * obj0 = 0 ;
19615 PyObject * obj1 = 0 ;
19616 char *kwnames[] = {
19617 (char *) "self",(char *) "m_keyCode", NULL
19618 };
19619
19620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
19621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19622 if (SWIG_arg_fail(1)) SWIG_fail;
19623 {
19624 arg2 = static_cast<long >(SWIG_As_long(obj1));
19625 if (SWIG_arg_fail(2)) SWIG_fail;
19626 }
19627 if (arg1) (arg1)->m_keyCode = arg2;
19628
19629 Py_INCREF(Py_None); resultobj = Py_None;
19630 return resultobj;
19631 fail:
19632 return NULL;
19633 }
19634
19635
19636 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19637 PyObject *resultobj = NULL;
19638 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19639 long result;
19640 PyObject * obj0 = 0 ;
19641 char *kwnames[] = {
19642 (char *) "self", NULL
19643 };
19644
19645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
19646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19647 if (SWIG_arg_fail(1)) SWIG_fail;
19648 result = (long) ((arg1)->m_keyCode);
19649
19650 {
19651 resultobj = SWIG_From_long(static_cast<long >(result));
19652 }
19653 return resultobj;
19654 fail:
19655 return NULL;
19656 }
19657
19658
19659 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19660 PyObject *resultobj = NULL;
19661 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19662 bool arg2 ;
19663 PyObject * obj0 = 0 ;
19664 PyObject * obj1 = 0 ;
19665 char *kwnames[] = {
19666 (char *) "self",(char *) "m_controlDown", NULL
19667 };
19668
19669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
19670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19671 if (SWIG_arg_fail(1)) SWIG_fail;
19672 {
19673 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19674 if (SWIG_arg_fail(2)) SWIG_fail;
19675 }
19676 if (arg1) (arg1)->m_controlDown = arg2;
19677
19678 Py_INCREF(Py_None); resultobj = Py_None;
19679 return resultobj;
19680 fail:
19681 return NULL;
19682 }
19683
19684
19685 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19686 PyObject *resultobj = NULL;
19687 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19688 bool result;
19689 PyObject * obj0 = 0 ;
19690 char *kwnames[] = {
19691 (char *) "self", NULL
19692 };
19693
19694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
19695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19696 if (SWIG_arg_fail(1)) SWIG_fail;
19697 result = (bool) ((arg1)->m_controlDown);
19698
19699 {
19700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19701 }
19702 return resultobj;
19703 fail:
19704 return NULL;
19705 }
19706
19707
19708 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19709 PyObject *resultobj = NULL;
19710 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19711 bool arg2 ;
19712 PyObject * obj0 = 0 ;
19713 PyObject * obj1 = 0 ;
19714 char *kwnames[] = {
19715 (char *) "self",(char *) "m_shiftDown", NULL
19716 };
19717
19718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
19719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19720 if (SWIG_arg_fail(1)) SWIG_fail;
19721 {
19722 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19723 if (SWIG_arg_fail(2)) SWIG_fail;
19724 }
19725 if (arg1) (arg1)->m_shiftDown = arg2;
19726
19727 Py_INCREF(Py_None); resultobj = Py_None;
19728 return resultobj;
19729 fail:
19730 return NULL;
19731 }
19732
19733
19734 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19735 PyObject *resultobj = NULL;
19736 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19737 bool result;
19738 PyObject * obj0 = 0 ;
19739 char *kwnames[] = {
19740 (char *) "self", NULL
19741 };
19742
19743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
19744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19745 if (SWIG_arg_fail(1)) SWIG_fail;
19746 result = (bool) ((arg1)->m_shiftDown);
19747
19748 {
19749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19750 }
19751 return resultobj;
19752 fail:
19753 return NULL;
19754 }
19755
19756
19757 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19758 PyObject *resultobj = NULL;
19759 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19760 bool arg2 ;
19761 PyObject * obj0 = 0 ;
19762 PyObject * obj1 = 0 ;
19763 char *kwnames[] = {
19764 (char *) "self",(char *) "m_altDown", NULL
19765 };
19766
19767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19769 if (SWIG_arg_fail(1)) SWIG_fail;
19770 {
19771 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19772 if (SWIG_arg_fail(2)) SWIG_fail;
19773 }
19774 if (arg1) (arg1)->m_altDown = arg2;
19775
19776 Py_INCREF(Py_None); resultobj = Py_None;
19777 return resultobj;
19778 fail:
19779 return NULL;
19780 }
19781
19782
19783 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19784 PyObject *resultobj = NULL;
19785 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19786 bool result;
19787 PyObject * obj0 = 0 ;
19788 char *kwnames[] = {
19789 (char *) "self", NULL
19790 };
19791
19792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19794 if (SWIG_arg_fail(1)) SWIG_fail;
19795 result = (bool) ((arg1)->m_altDown);
19796
19797 {
19798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19799 }
19800 return resultobj;
19801 fail:
19802 return NULL;
19803 }
19804
19805
19806 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19807 PyObject *resultobj = NULL;
19808 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19809 bool arg2 ;
19810 PyObject * obj0 = 0 ;
19811 PyObject * obj1 = 0 ;
19812 char *kwnames[] = {
19813 (char *) "self",(char *) "m_metaDown", NULL
19814 };
19815
19816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19818 if (SWIG_arg_fail(1)) SWIG_fail;
19819 {
19820 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19821 if (SWIG_arg_fail(2)) SWIG_fail;
19822 }
19823 if (arg1) (arg1)->m_metaDown = arg2;
19824
19825 Py_INCREF(Py_None); resultobj = Py_None;
19826 return resultobj;
19827 fail:
19828 return NULL;
19829 }
19830
19831
19832 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19833 PyObject *resultobj = NULL;
19834 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19835 bool result;
19836 PyObject * obj0 = 0 ;
19837 char *kwnames[] = {
19838 (char *) "self", NULL
19839 };
19840
19841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19843 if (SWIG_arg_fail(1)) SWIG_fail;
19844 result = (bool) ((arg1)->m_metaDown);
19845
19846 {
19847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19848 }
19849 return resultobj;
19850 fail:
19851 return NULL;
19852 }
19853
19854
19855 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19856 PyObject *resultobj = NULL;
19857 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19858 bool arg2 ;
19859 PyObject * obj0 = 0 ;
19860 PyObject * obj1 = 0 ;
19861 char *kwnames[] = {
19862 (char *) "self",(char *) "m_scanCode", NULL
19863 };
19864
19865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19867 if (SWIG_arg_fail(1)) SWIG_fail;
19868 {
19869 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
19870 if (SWIG_arg_fail(2)) SWIG_fail;
19871 }
19872 if (arg1) (arg1)->m_scanCode = arg2;
19873
19874 Py_INCREF(Py_None); resultobj = Py_None;
19875 return resultobj;
19876 fail:
19877 return NULL;
19878 }
19879
19880
19881 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19882 PyObject *resultobj = NULL;
19883 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19884 bool result;
19885 PyObject * obj0 = 0 ;
19886 char *kwnames[] = {
19887 (char *) "self", NULL
19888 };
19889
19890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19892 if (SWIG_arg_fail(1)) SWIG_fail;
19893 result = (bool) ((arg1)->m_scanCode);
19894
19895 {
19896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19897 }
19898 return resultobj;
19899 fail:
19900 return NULL;
19901 }
19902
19903
19904 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19905 PyObject *resultobj = NULL;
19906 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19907 unsigned int arg2 ;
19908 PyObject * obj0 = 0 ;
19909 PyObject * obj1 = 0 ;
19910 char *kwnames[] = {
19911 (char *) "self",(char *) "m_rawCode", NULL
19912 };
19913
19914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19916 if (SWIG_arg_fail(1)) SWIG_fail;
19917 {
19918 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
19919 if (SWIG_arg_fail(2)) SWIG_fail;
19920 }
19921 if (arg1) (arg1)->m_rawCode = arg2;
19922
19923 Py_INCREF(Py_None); resultobj = Py_None;
19924 return resultobj;
19925 fail:
19926 return NULL;
19927 }
19928
19929
19930 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19931 PyObject *resultobj = NULL;
19932 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19933 unsigned int result;
19934 PyObject * obj0 = 0 ;
19935 char *kwnames[] = {
19936 (char *) "self", NULL
19937 };
19938
19939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19941 if (SWIG_arg_fail(1)) SWIG_fail;
19942 result = (unsigned int) ((arg1)->m_rawCode);
19943
19944 {
19945 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19946 }
19947 return resultobj;
19948 fail:
19949 return NULL;
19950 }
19951
19952
19953 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19954 PyObject *resultobj = NULL;
19955 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19956 unsigned int arg2 ;
19957 PyObject * obj0 = 0 ;
19958 PyObject * obj1 = 0 ;
19959 char *kwnames[] = {
19960 (char *) "self",(char *) "m_rawFlags", NULL
19961 };
19962
19963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19965 if (SWIG_arg_fail(1)) SWIG_fail;
19966 {
19967 arg2 = static_cast<unsigned int >(SWIG_As_unsigned_SS_int(obj1));
19968 if (SWIG_arg_fail(2)) SWIG_fail;
19969 }
19970 if (arg1) (arg1)->m_rawFlags = arg2;
19971
19972 Py_INCREF(Py_None); resultobj = Py_None;
19973 return resultobj;
19974 fail:
19975 return NULL;
19976 }
19977
19978
19979 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19980 PyObject *resultobj = NULL;
19981 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19982 unsigned int result;
19983 PyObject * obj0 = 0 ;
19984 char *kwnames[] = {
19985 (char *) "self", NULL
19986 };
19987
19988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19990 if (SWIG_arg_fail(1)) SWIG_fail;
19991 result = (unsigned int) ((arg1)->m_rawFlags);
19992
19993 {
19994 resultobj = SWIG_From_unsigned_SS_int(static_cast<unsigned int >(result));
19995 }
19996 return resultobj;
19997 fail:
19998 return NULL;
19999 }
20000
20001
20002 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
20003 PyObject *obj;
20004 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20005 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
20006 Py_INCREF(obj);
20007 return Py_BuildValue((char *)"");
20008 }
20009 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20010 PyObject *resultobj = NULL;
20011 wxSize const &arg1_defvalue = wxDefaultSize ;
20012 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
20013 int arg2 = (int) 0 ;
20014 wxSizeEvent *result;
20015 wxSize temp1 ;
20016 PyObject * obj0 = 0 ;
20017 PyObject * obj1 = 0 ;
20018 char *kwnames[] = {
20019 (char *) "sz",(char *) "winid", NULL
20020 };
20021
20022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
20023 if (obj0) {
20024 {
20025 arg1 = &temp1;
20026 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
20027 }
20028 }
20029 if (obj1) {
20030 {
20031 arg2 = static_cast<int >(SWIG_As_int(obj1));
20032 if (SWIG_arg_fail(2)) SWIG_fail;
20033 }
20034 }
20035 {
20036 PyThreadState* __tstate = wxPyBeginAllowThreads();
20037 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
20038
20039 wxPyEndAllowThreads(__tstate);
20040 if (PyErr_Occurred()) SWIG_fail;
20041 }
20042 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
20043 return resultobj;
20044 fail:
20045 return NULL;
20046 }
20047
20048
20049 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
20050 PyObject *resultobj = NULL;
20051 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20052 wxSize result;
20053 PyObject * obj0 = 0 ;
20054 char *kwnames[] = {
20055 (char *) "self", NULL
20056 };
20057
20058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
20059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20060 if (SWIG_arg_fail(1)) SWIG_fail;
20061 {
20062 PyThreadState* __tstate = wxPyBeginAllowThreads();
20063 result = ((wxSizeEvent const *)arg1)->GetSize();
20064
20065 wxPyEndAllowThreads(__tstate);
20066 if (PyErr_Occurred()) SWIG_fail;
20067 }
20068 {
20069 wxSize * resultptr;
20070 resultptr = new wxSize(static_cast<wxSize & >(result));
20071 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
20072 }
20073 return resultobj;
20074 fail:
20075 return NULL;
20076 }
20077
20078
20079 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20080 PyObject *resultobj = NULL;
20081 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20082 wxRect result;
20083 PyObject * obj0 = 0 ;
20084 char *kwnames[] = {
20085 (char *) "self", NULL
20086 };
20087
20088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
20089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20090 if (SWIG_arg_fail(1)) SWIG_fail;
20091 {
20092 PyThreadState* __tstate = wxPyBeginAllowThreads();
20093 result = ((wxSizeEvent const *)arg1)->GetRect();
20094
20095 wxPyEndAllowThreads(__tstate);
20096 if (PyErr_Occurred()) SWIG_fail;
20097 }
20098 {
20099 wxRect * resultptr;
20100 resultptr = new wxRect(static_cast<wxRect & >(result));
20101 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20102 }
20103 return resultobj;
20104 fail:
20105 return NULL;
20106 }
20107
20108
20109 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20110 PyObject *resultobj = NULL;
20111 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20112 wxRect arg2 ;
20113 PyObject * obj0 = 0 ;
20114 PyObject * obj1 = 0 ;
20115 char *kwnames[] = {
20116 (char *) "self",(char *) "rect", NULL
20117 };
20118
20119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20121 if (SWIG_arg_fail(1)) SWIG_fail;
20122 {
20123 wxRect * argp;
20124 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
20125 if (SWIG_arg_fail(2)) SWIG_fail;
20126 if (argp == NULL) {
20127 SWIG_null_ref("wxRect");
20128 }
20129 if (SWIG_arg_fail(2)) SWIG_fail;
20130 arg2 = *argp;
20131 }
20132 {
20133 PyThreadState* __tstate = wxPyBeginAllowThreads();
20134 (arg1)->SetRect(arg2);
20135
20136 wxPyEndAllowThreads(__tstate);
20137 if (PyErr_Occurred()) SWIG_fail;
20138 }
20139 Py_INCREF(Py_None); resultobj = Py_None;
20140 return resultobj;
20141 fail:
20142 return NULL;
20143 }
20144
20145
20146 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
20147 PyObject *resultobj = NULL;
20148 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20149 wxSize arg2 ;
20150 PyObject * obj0 = 0 ;
20151 PyObject * obj1 = 0 ;
20152 char *kwnames[] = {
20153 (char *) "self",(char *) "size", NULL
20154 };
20155
20156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
20157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20158 if (SWIG_arg_fail(1)) SWIG_fail;
20159 {
20160 wxSize * argp;
20161 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
20162 if (SWIG_arg_fail(2)) SWIG_fail;
20163 if (argp == NULL) {
20164 SWIG_null_ref("wxSize");
20165 }
20166 if (SWIG_arg_fail(2)) SWIG_fail;
20167 arg2 = *argp;
20168 }
20169 {
20170 PyThreadState* __tstate = wxPyBeginAllowThreads();
20171 wxSizeEvent_SetSize(arg1,arg2);
20172
20173 wxPyEndAllowThreads(__tstate);
20174 if (PyErr_Occurred()) SWIG_fail;
20175 }
20176 Py_INCREF(Py_None); resultobj = Py_None;
20177 return resultobj;
20178 fail:
20179 return NULL;
20180 }
20181
20182
20183 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
20184 PyObject *resultobj = NULL;
20185 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20186 wxSize *arg2 = (wxSize *) 0 ;
20187 PyObject * obj0 = 0 ;
20188 PyObject * obj1 = 0 ;
20189 char *kwnames[] = {
20190 (char *) "self",(char *) "m_size", NULL
20191 };
20192
20193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
20194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20195 if (SWIG_arg_fail(1)) SWIG_fail;
20196 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
20197 if (SWIG_arg_fail(2)) SWIG_fail;
20198 if (arg1) (arg1)->m_size = *arg2;
20199
20200 Py_INCREF(Py_None); resultobj = Py_None;
20201 return resultobj;
20202 fail:
20203 return NULL;
20204 }
20205
20206
20207 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
20208 PyObject *resultobj = NULL;
20209 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20210 wxSize *result;
20211 PyObject * obj0 = 0 ;
20212 char *kwnames[] = {
20213 (char *) "self", NULL
20214 };
20215
20216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
20217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20218 if (SWIG_arg_fail(1)) SWIG_fail;
20219 result = (wxSize *)& ((arg1)->m_size);
20220
20221 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
20222 return resultobj;
20223 fail:
20224 return NULL;
20225 }
20226
20227
20228 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
20229 PyObject *resultobj = NULL;
20230 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20231 wxRect *arg2 = (wxRect *) 0 ;
20232 PyObject * obj0 = 0 ;
20233 PyObject * obj1 = 0 ;
20234 char *kwnames[] = {
20235 (char *) "self",(char *) "m_rect", NULL
20236 };
20237
20238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
20239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20240 if (SWIG_arg_fail(1)) SWIG_fail;
20241 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
20242 if (SWIG_arg_fail(2)) SWIG_fail;
20243 if (arg1) (arg1)->m_rect = *arg2;
20244
20245 Py_INCREF(Py_None); resultobj = Py_None;
20246 return resultobj;
20247 fail:
20248 return NULL;
20249 }
20250
20251
20252 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
20253 PyObject *resultobj = NULL;
20254 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20255 wxRect *result;
20256 PyObject * obj0 = 0 ;
20257 char *kwnames[] = {
20258 (char *) "self", NULL
20259 };
20260
20261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
20262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20263 if (SWIG_arg_fail(1)) SWIG_fail;
20264 result = (wxRect *)& ((arg1)->m_rect);
20265
20266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
20267 return resultobj;
20268 fail:
20269 return NULL;
20270 }
20271
20272
20273 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
20274 PyObject *obj;
20275 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20276 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
20277 Py_INCREF(obj);
20278 return Py_BuildValue((char *)"");
20279 }
20280 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20281 PyObject *resultobj = NULL;
20282 wxPoint const &arg1_defvalue = wxDefaultPosition ;
20283 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
20284 int arg2 = (int) 0 ;
20285 wxMoveEvent *result;
20286 wxPoint temp1 ;
20287 PyObject * obj0 = 0 ;
20288 PyObject * obj1 = 0 ;
20289 char *kwnames[] = {
20290 (char *) "pos",(char *) "winid", NULL
20291 };
20292
20293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
20294 if (obj0) {
20295 {
20296 arg1 = &temp1;
20297 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
20298 }
20299 }
20300 if (obj1) {
20301 {
20302 arg2 = static_cast<int >(SWIG_As_int(obj1));
20303 if (SWIG_arg_fail(2)) SWIG_fail;
20304 }
20305 }
20306 {
20307 PyThreadState* __tstate = wxPyBeginAllowThreads();
20308 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
20309
20310 wxPyEndAllowThreads(__tstate);
20311 if (PyErr_Occurred()) SWIG_fail;
20312 }
20313 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
20314 return resultobj;
20315 fail:
20316 return NULL;
20317 }
20318
20319
20320 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20321 PyObject *resultobj = NULL;
20322 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20323 wxPoint result;
20324 PyObject * obj0 = 0 ;
20325 char *kwnames[] = {
20326 (char *) "self", NULL
20327 };
20328
20329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
20330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20331 if (SWIG_arg_fail(1)) SWIG_fail;
20332 {
20333 PyThreadState* __tstate = wxPyBeginAllowThreads();
20334 result = ((wxMoveEvent const *)arg1)->GetPosition();
20335
20336 wxPyEndAllowThreads(__tstate);
20337 if (PyErr_Occurred()) SWIG_fail;
20338 }
20339 {
20340 wxPoint * resultptr;
20341 resultptr = new wxPoint(static_cast<wxPoint & >(result));
20342 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20343 }
20344 return resultobj;
20345 fail:
20346 return NULL;
20347 }
20348
20349
20350 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20351 PyObject *resultobj = NULL;
20352 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20353 wxRect result;
20354 PyObject * obj0 = 0 ;
20355 char *kwnames[] = {
20356 (char *) "self", NULL
20357 };
20358
20359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
20360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20361 if (SWIG_arg_fail(1)) SWIG_fail;
20362 {
20363 PyThreadState* __tstate = wxPyBeginAllowThreads();
20364 result = ((wxMoveEvent const *)arg1)->GetRect();
20365
20366 wxPyEndAllowThreads(__tstate);
20367 if (PyErr_Occurred()) SWIG_fail;
20368 }
20369 {
20370 wxRect * resultptr;
20371 resultptr = new wxRect(static_cast<wxRect & >(result));
20372 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20373 }
20374 return resultobj;
20375 fail:
20376 return NULL;
20377 }
20378
20379
20380 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20381 PyObject *resultobj = NULL;
20382 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20383 wxRect *arg2 = 0 ;
20384 wxRect temp2 ;
20385 PyObject * obj0 = 0 ;
20386 PyObject * obj1 = 0 ;
20387 char *kwnames[] = {
20388 (char *) "self",(char *) "rect", NULL
20389 };
20390
20391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20393 if (SWIG_arg_fail(1)) SWIG_fail;
20394 {
20395 arg2 = &temp2;
20396 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20397 }
20398 {
20399 PyThreadState* __tstate = wxPyBeginAllowThreads();
20400 (arg1)->SetRect((wxRect const &)*arg2);
20401
20402 wxPyEndAllowThreads(__tstate);
20403 if (PyErr_Occurred()) SWIG_fail;
20404 }
20405 Py_INCREF(Py_None); resultobj = Py_None;
20406 return resultobj;
20407 fail:
20408 return NULL;
20409 }
20410
20411
20412 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20413 PyObject *resultobj = NULL;
20414 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20415 wxPoint *arg2 = 0 ;
20416 wxPoint temp2 ;
20417 PyObject * obj0 = 0 ;
20418 PyObject * obj1 = 0 ;
20419 char *kwnames[] = {
20420 (char *) "self",(char *) "pos", NULL
20421 };
20422
20423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
20424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20425 if (SWIG_arg_fail(1)) SWIG_fail;
20426 {
20427 arg2 = &temp2;
20428 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
20429 }
20430 {
20431 PyThreadState* __tstate = wxPyBeginAllowThreads();
20432 (arg1)->SetPosition((wxPoint const &)*arg2);
20433
20434 wxPyEndAllowThreads(__tstate);
20435 if (PyErr_Occurred()) SWIG_fail;
20436 }
20437 Py_INCREF(Py_None); resultobj = Py_None;
20438 return resultobj;
20439 fail:
20440 return NULL;
20441 }
20442
20443
20444 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
20445 PyObject *obj;
20446 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20447 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
20448 Py_INCREF(obj);
20449 return Py_BuildValue((char *)"");
20450 }
20451 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20452 PyObject *resultobj = NULL;
20453 int arg1 = (int) 0 ;
20454 wxPaintEvent *result;
20455 PyObject * obj0 = 0 ;
20456 char *kwnames[] = {
20457 (char *) "Id", NULL
20458 };
20459
20460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
20461 if (obj0) {
20462 {
20463 arg1 = static_cast<int >(SWIG_As_int(obj0));
20464 if (SWIG_arg_fail(1)) SWIG_fail;
20465 }
20466 }
20467 {
20468 PyThreadState* __tstate = wxPyBeginAllowThreads();
20469 result = (wxPaintEvent *)new wxPaintEvent(arg1);
20470
20471 wxPyEndAllowThreads(__tstate);
20472 if (PyErr_Occurred()) SWIG_fail;
20473 }
20474 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
20475 return resultobj;
20476 fail:
20477 return NULL;
20478 }
20479
20480
20481 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
20482 PyObject *obj;
20483 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20484 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
20485 Py_INCREF(obj);
20486 return Py_BuildValue((char *)"");
20487 }
20488 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20489 PyObject *resultobj = NULL;
20490 int arg1 = (int) 0 ;
20491 wxNcPaintEvent *result;
20492 PyObject * obj0 = 0 ;
20493 char *kwnames[] = {
20494 (char *) "winid", NULL
20495 };
20496
20497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
20498 if (obj0) {
20499 {
20500 arg1 = static_cast<int >(SWIG_As_int(obj0));
20501 if (SWIG_arg_fail(1)) SWIG_fail;
20502 }
20503 }
20504 {
20505 PyThreadState* __tstate = wxPyBeginAllowThreads();
20506 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
20507
20508 wxPyEndAllowThreads(__tstate);
20509 if (PyErr_Occurred()) SWIG_fail;
20510 }
20511 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
20512 return resultobj;
20513 fail:
20514 return NULL;
20515 }
20516
20517
20518 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
20519 PyObject *obj;
20520 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20521 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
20522 Py_INCREF(obj);
20523 return Py_BuildValue((char *)"");
20524 }
20525 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20526 PyObject *resultobj = NULL;
20527 int arg1 = (int) 0 ;
20528 wxDC *arg2 = (wxDC *) NULL ;
20529 wxEraseEvent *result;
20530 PyObject * obj0 = 0 ;
20531 PyObject * obj1 = 0 ;
20532 char *kwnames[] = {
20533 (char *) "Id",(char *) "dc", NULL
20534 };
20535
20536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
20537 if (obj0) {
20538 {
20539 arg1 = static_cast<int >(SWIG_As_int(obj0));
20540 if (SWIG_arg_fail(1)) SWIG_fail;
20541 }
20542 }
20543 if (obj1) {
20544 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20545 if (SWIG_arg_fail(2)) SWIG_fail;
20546 }
20547 {
20548 PyThreadState* __tstate = wxPyBeginAllowThreads();
20549 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
20550
20551 wxPyEndAllowThreads(__tstate);
20552 if (PyErr_Occurred()) SWIG_fail;
20553 }
20554 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
20555 return resultobj;
20556 fail:
20557 return NULL;
20558 }
20559
20560
20561 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
20562 PyObject *resultobj = NULL;
20563 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
20564 wxDC *result;
20565 PyObject * obj0 = 0 ;
20566 char *kwnames[] = {
20567 (char *) "self", NULL
20568 };
20569
20570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
20571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
20572 if (SWIG_arg_fail(1)) SWIG_fail;
20573 {
20574 PyThreadState* __tstate = wxPyBeginAllowThreads();
20575 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
20576
20577 wxPyEndAllowThreads(__tstate);
20578 if (PyErr_Occurred()) SWIG_fail;
20579 }
20580 {
20581 resultobj = wxPyMake_wxObject(result, (bool)0);
20582 }
20583 return resultobj;
20584 fail:
20585 return NULL;
20586 }
20587
20588
20589 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
20590 PyObject *obj;
20591 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20592 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
20593 Py_INCREF(obj);
20594 return Py_BuildValue((char *)"");
20595 }
20596 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20597 PyObject *resultobj = NULL;
20598 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20599 int arg2 = (int) 0 ;
20600 wxFocusEvent *result;
20601 PyObject * obj0 = 0 ;
20602 PyObject * obj1 = 0 ;
20603 char *kwnames[] = {
20604 (char *) "type",(char *) "winid", NULL
20605 };
20606
20607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
20608 if (obj0) {
20609 {
20610 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20611 if (SWIG_arg_fail(1)) SWIG_fail;
20612 }
20613 }
20614 if (obj1) {
20615 {
20616 arg2 = static_cast<int >(SWIG_As_int(obj1));
20617 if (SWIG_arg_fail(2)) SWIG_fail;
20618 }
20619 }
20620 {
20621 PyThreadState* __tstate = wxPyBeginAllowThreads();
20622 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
20623
20624 wxPyEndAllowThreads(__tstate);
20625 if (PyErr_Occurred()) SWIG_fail;
20626 }
20627 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
20628 return resultobj;
20629 fail:
20630 return NULL;
20631 }
20632
20633
20634 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20635 PyObject *resultobj = NULL;
20636 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20637 wxWindow *result;
20638 PyObject * obj0 = 0 ;
20639 char *kwnames[] = {
20640 (char *) "self", NULL
20641 };
20642
20643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20645 if (SWIG_arg_fail(1)) SWIG_fail;
20646 {
20647 PyThreadState* __tstate = wxPyBeginAllowThreads();
20648 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
20649
20650 wxPyEndAllowThreads(__tstate);
20651 if (PyErr_Occurred()) SWIG_fail;
20652 }
20653 {
20654 resultobj = wxPyMake_wxObject(result, (bool)0);
20655 }
20656 return resultobj;
20657 fail:
20658 return NULL;
20659 }
20660
20661
20662 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20663 PyObject *resultobj = NULL;
20664 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20665 wxWindow *arg2 = (wxWindow *) 0 ;
20666 PyObject * obj0 = 0 ;
20667 PyObject * obj1 = 0 ;
20668 char *kwnames[] = {
20669 (char *) "self",(char *) "win", NULL
20670 };
20671
20672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
20673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20674 if (SWIG_arg_fail(1)) SWIG_fail;
20675 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20676 if (SWIG_arg_fail(2)) SWIG_fail;
20677 {
20678 PyThreadState* __tstate = wxPyBeginAllowThreads();
20679 (arg1)->SetWindow(arg2);
20680
20681 wxPyEndAllowThreads(__tstate);
20682 if (PyErr_Occurred()) SWIG_fail;
20683 }
20684 Py_INCREF(Py_None); resultobj = Py_None;
20685 return resultobj;
20686 fail:
20687 return NULL;
20688 }
20689
20690
20691 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
20692 PyObject *obj;
20693 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20694 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
20695 Py_INCREF(obj);
20696 return Py_BuildValue((char *)"");
20697 }
20698 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20699 PyObject *resultobj = NULL;
20700 wxWindow *arg1 = (wxWindow *) NULL ;
20701 wxChildFocusEvent *result;
20702 PyObject * obj0 = 0 ;
20703 char *kwnames[] = {
20704 (char *) "win", NULL
20705 };
20706
20707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
20708 if (obj0) {
20709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20710 if (SWIG_arg_fail(1)) SWIG_fail;
20711 }
20712 {
20713 PyThreadState* __tstate = wxPyBeginAllowThreads();
20714 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
20715
20716 wxPyEndAllowThreads(__tstate);
20717 if (PyErr_Occurred()) SWIG_fail;
20718 }
20719 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
20720 return resultobj;
20721 fail:
20722 return NULL;
20723 }
20724
20725
20726 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20727 PyObject *resultobj = NULL;
20728 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
20729 wxWindow *result;
20730 PyObject * obj0 = 0 ;
20731 char *kwnames[] = {
20732 (char *) "self", NULL
20733 };
20734
20735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20737 if (SWIG_arg_fail(1)) SWIG_fail;
20738 {
20739 PyThreadState* __tstate = wxPyBeginAllowThreads();
20740 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
20741
20742 wxPyEndAllowThreads(__tstate);
20743 if (PyErr_Occurred()) SWIG_fail;
20744 }
20745 {
20746 resultobj = wxPyMake_wxObject(result, (bool)0);
20747 }
20748 return resultobj;
20749 fail:
20750 return NULL;
20751 }
20752
20753
20754 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
20755 PyObject *obj;
20756 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20757 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
20758 Py_INCREF(obj);
20759 return Py_BuildValue((char *)"");
20760 }
20761 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20762 PyObject *resultobj = NULL;
20763 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20764 bool arg2 = (bool) true ;
20765 int arg3 = (int) 0 ;
20766 wxActivateEvent *result;
20767 PyObject * obj0 = 0 ;
20768 PyObject * obj1 = 0 ;
20769 PyObject * obj2 = 0 ;
20770 char *kwnames[] = {
20771 (char *) "type",(char *) "active",(char *) "Id", NULL
20772 };
20773
20774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20775 if (obj0) {
20776 {
20777 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20778 if (SWIG_arg_fail(1)) SWIG_fail;
20779 }
20780 }
20781 if (obj1) {
20782 {
20783 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
20784 if (SWIG_arg_fail(2)) SWIG_fail;
20785 }
20786 }
20787 if (obj2) {
20788 {
20789 arg3 = static_cast<int >(SWIG_As_int(obj2));
20790 if (SWIG_arg_fail(3)) SWIG_fail;
20791 }
20792 }
20793 {
20794 PyThreadState* __tstate = wxPyBeginAllowThreads();
20795 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20796
20797 wxPyEndAllowThreads(__tstate);
20798 if (PyErr_Occurred()) SWIG_fail;
20799 }
20800 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20801 return resultobj;
20802 fail:
20803 return NULL;
20804 }
20805
20806
20807 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20808 PyObject *resultobj = NULL;
20809 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20810 bool result;
20811 PyObject * obj0 = 0 ;
20812 char *kwnames[] = {
20813 (char *) "self", NULL
20814 };
20815
20816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20818 if (SWIG_arg_fail(1)) SWIG_fail;
20819 {
20820 PyThreadState* __tstate = wxPyBeginAllowThreads();
20821 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20822
20823 wxPyEndAllowThreads(__tstate);
20824 if (PyErr_Occurred()) SWIG_fail;
20825 }
20826 {
20827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20828 }
20829 return resultobj;
20830 fail:
20831 return NULL;
20832 }
20833
20834
20835 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20836 PyObject *obj;
20837 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20838 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20839 Py_INCREF(obj);
20840 return Py_BuildValue((char *)"");
20841 }
20842 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20843 PyObject *resultobj = NULL;
20844 int arg1 = (int) 0 ;
20845 wxInitDialogEvent *result;
20846 PyObject * obj0 = 0 ;
20847 char *kwnames[] = {
20848 (char *) "Id", NULL
20849 };
20850
20851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20852 if (obj0) {
20853 {
20854 arg1 = static_cast<int >(SWIG_As_int(obj0));
20855 if (SWIG_arg_fail(1)) SWIG_fail;
20856 }
20857 }
20858 {
20859 PyThreadState* __tstate = wxPyBeginAllowThreads();
20860 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20861
20862 wxPyEndAllowThreads(__tstate);
20863 if (PyErr_Occurred()) SWIG_fail;
20864 }
20865 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20866 return resultobj;
20867 fail:
20868 return NULL;
20869 }
20870
20871
20872 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20873 PyObject *obj;
20874 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20875 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20876 Py_INCREF(obj);
20877 return Py_BuildValue((char *)"");
20878 }
20879 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20880 PyObject *resultobj = NULL;
20881 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20882 int arg2 = (int) 0 ;
20883 wxMenu *arg3 = (wxMenu *) NULL ;
20884 wxMenuEvent *result;
20885 PyObject * obj0 = 0 ;
20886 PyObject * obj1 = 0 ;
20887 PyObject * obj2 = 0 ;
20888 char *kwnames[] = {
20889 (char *) "type",(char *) "winid",(char *) "menu", NULL
20890 };
20891
20892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20893 if (obj0) {
20894 {
20895 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
20896 if (SWIG_arg_fail(1)) SWIG_fail;
20897 }
20898 }
20899 if (obj1) {
20900 {
20901 arg2 = static_cast<int >(SWIG_As_int(obj1));
20902 if (SWIG_arg_fail(2)) SWIG_fail;
20903 }
20904 }
20905 if (obj2) {
20906 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20907 if (SWIG_arg_fail(3)) SWIG_fail;
20908 }
20909 {
20910 PyThreadState* __tstate = wxPyBeginAllowThreads();
20911 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20912
20913 wxPyEndAllowThreads(__tstate);
20914 if (PyErr_Occurred()) SWIG_fail;
20915 }
20916 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20917 return resultobj;
20918 fail:
20919 return NULL;
20920 }
20921
20922
20923 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20924 PyObject *resultobj = NULL;
20925 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20926 int result;
20927 PyObject * obj0 = 0 ;
20928 char *kwnames[] = {
20929 (char *) "self", NULL
20930 };
20931
20932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20934 if (SWIG_arg_fail(1)) SWIG_fail;
20935 {
20936 PyThreadState* __tstate = wxPyBeginAllowThreads();
20937 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20938
20939 wxPyEndAllowThreads(__tstate);
20940 if (PyErr_Occurred()) SWIG_fail;
20941 }
20942 {
20943 resultobj = SWIG_From_int(static_cast<int >(result));
20944 }
20945 return resultobj;
20946 fail:
20947 return NULL;
20948 }
20949
20950
20951 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20952 PyObject *resultobj = NULL;
20953 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20954 bool result;
20955 PyObject * obj0 = 0 ;
20956 char *kwnames[] = {
20957 (char *) "self", NULL
20958 };
20959
20960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20962 if (SWIG_arg_fail(1)) SWIG_fail;
20963 {
20964 PyThreadState* __tstate = wxPyBeginAllowThreads();
20965 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20966
20967 wxPyEndAllowThreads(__tstate);
20968 if (PyErr_Occurred()) SWIG_fail;
20969 }
20970 {
20971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20972 }
20973 return resultobj;
20974 fail:
20975 return NULL;
20976 }
20977
20978
20979 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20980 PyObject *resultobj = NULL;
20981 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20982 wxMenu *result;
20983 PyObject * obj0 = 0 ;
20984 char *kwnames[] = {
20985 (char *) "self", NULL
20986 };
20987
20988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20990 if (SWIG_arg_fail(1)) SWIG_fail;
20991 {
20992 PyThreadState* __tstate = wxPyBeginAllowThreads();
20993 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20994
20995 wxPyEndAllowThreads(__tstate);
20996 if (PyErr_Occurred()) SWIG_fail;
20997 }
20998 {
20999 resultobj = wxPyMake_wxObject(result, (bool)0);
21000 }
21001 return resultobj;
21002 fail:
21003 return NULL;
21004 }
21005
21006
21007 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
21008 PyObject *obj;
21009 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21010 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
21011 Py_INCREF(obj);
21012 return Py_BuildValue((char *)"");
21013 }
21014 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21015 PyObject *resultobj = NULL;
21016 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21017 int arg2 = (int) 0 ;
21018 wxCloseEvent *result;
21019 PyObject * obj0 = 0 ;
21020 PyObject * obj1 = 0 ;
21021 char *kwnames[] = {
21022 (char *) "type",(char *) "winid", NULL
21023 };
21024
21025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
21026 if (obj0) {
21027 {
21028 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
21029 if (SWIG_arg_fail(1)) SWIG_fail;
21030 }
21031 }
21032 if (obj1) {
21033 {
21034 arg2 = static_cast<int >(SWIG_As_int(obj1));
21035 if (SWIG_arg_fail(2)) SWIG_fail;
21036 }
21037 }
21038 {
21039 PyThreadState* __tstate = wxPyBeginAllowThreads();
21040 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
21041
21042 wxPyEndAllowThreads(__tstate);
21043 if (PyErr_Occurred()) SWIG_fail;
21044 }
21045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
21046 return resultobj;
21047 fail:
21048 return NULL;
21049 }
21050
21051
21052 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
21053 PyObject *resultobj = NULL;
21054 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21055 bool arg2 ;
21056 PyObject * obj0 = 0 ;
21057 PyObject * obj1 = 0 ;
21058 char *kwnames[] = {
21059 (char *) "self",(char *) "logOff", NULL
21060 };
21061
21062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
21063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21064 if (SWIG_arg_fail(1)) SWIG_fail;
21065 {
21066 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21067 if (SWIG_arg_fail(2)) SWIG_fail;
21068 }
21069 {
21070 PyThreadState* __tstate = wxPyBeginAllowThreads();
21071 (arg1)->SetLoggingOff(arg2);
21072
21073 wxPyEndAllowThreads(__tstate);
21074 if (PyErr_Occurred()) SWIG_fail;
21075 }
21076 Py_INCREF(Py_None); resultobj = Py_None;
21077 return resultobj;
21078 fail:
21079 return NULL;
21080 }
21081
21082
21083 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
21084 PyObject *resultobj = NULL;
21085 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21086 bool result;
21087 PyObject * obj0 = 0 ;
21088 char *kwnames[] = {
21089 (char *) "self", NULL
21090 };
21091
21092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
21093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21094 if (SWIG_arg_fail(1)) SWIG_fail;
21095 {
21096 PyThreadState* __tstate = wxPyBeginAllowThreads();
21097 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
21098
21099 wxPyEndAllowThreads(__tstate);
21100 if (PyErr_Occurred()) SWIG_fail;
21101 }
21102 {
21103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21104 }
21105 return resultobj;
21106 fail:
21107 return NULL;
21108 }
21109
21110
21111 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
21112 PyObject *resultobj = NULL;
21113 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21114 bool arg2 = (bool) true ;
21115 PyObject * obj0 = 0 ;
21116 PyObject * obj1 = 0 ;
21117 char *kwnames[] = {
21118 (char *) "self",(char *) "veto", NULL
21119 };
21120
21121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
21122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21123 if (SWIG_arg_fail(1)) SWIG_fail;
21124 if (obj1) {
21125 {
21126 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21127 if (SWIG_arg_fail(2)) SWIG_fail;
21128 }
21129 }
21130 {
21131 PyThreadState* __tstate = wxPyBeginAllowThreads();
21132 (arg1)->Veto(arg2);
21133
21134 wxPyEndAllowThreads(__tstate);
21135 if (PyErr_Occurred()) SWIG_fail;
21136 }
21137 Py_INCREF(Py_None); resultobj = Py_None;
21138 return resultobj;
21139 fail:
21140 return NULL;
21141 }
21142
21143
21144 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21145 PyObject *resultobj = NULL;
21146 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21147 bool result;
21148 PyObject * obj0 = 0 ;
21149 char *kwnames[] = {
21150 (char *) "self", NULL
21151 };
21152
21153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
21154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21155 if (SWIG_arg_fail(1)) SWIG_fail;
21156 {
21157 PyThreadState* __tstate = wxPyBeginAllowThreads();
21158 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
21159
21160 wxPyEndAllowThreads(__tstate);
21161 if (PyErr_Occurred()) SWIG_fail;
21162 }
21163 {
21164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21165 }
21166 return resultobj;
21167 fail:
21168 return NULL;
21169 }
21170
21171
21172 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21173 PyObject *resultobj = NULL;
21174 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21175 bool arg2 ;
21176 PyObject * obj0 = 0 ;
21177 PyObject * obj1 = 0 ;
21178 char *kwnames[] = {
21179 (char *) "self",(char *) "canVeto", NULL
21180 };
21181
21182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
21183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21184 if (SWIG_arg_fail(1)) SWIG_fail;
21185 {
21186 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21187 if (SWIG_arg_fail(2)) SWIG_fail;
21188 }
21189 {
21190 PyThreadState* __tstate = wxPyBeginAllowThreads();
21191 (arg1)->SetCanVeto(arg2);
21192
21193 wxPyEndAllowThreads(__tstate);
21194 if (PyErr_Occurred()) SWIG_fail;
21195 }
21196 Py_INCREF(Py_None); resultobj = Py_None;
21197 return resultobj;
21198 fail:
21199 return NULL;
21200 }
21201
21202
21203 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
21204 PyObject *resultobj = NULL;
21205 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
21206 bool result;
21207 PyObject * obj0 = 0 ;
21208 char *kwnames[] = {
21209 (char *) "self", NULL
21210 };
21211
21212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
21213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
21214 if (SWIG_arg_fail(1)) SWIG_fail;
21215 {
21216 PyThreadState* __tstate = wxPyBeginAllowThreads();
21217 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
21218
21219 wxPyEndAllowThreads(__tstate);
21220 if (PyErr_Occurred()) SWIG_fail;
21221 }
21222 {
21223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21224 }
21225 return resultobj;
21226 fail:
21227 return NULL;
21228 }
21229
21230
21231 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
21232 PyObject *obj;
21233 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21234 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
21235 Py_INCREF(obj);
21236 return Py_BuildValue((char *)"");
21237 }
21238 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21239 PyObject *resultobj = NULL;
21240 int arg1 = (int) 0 ;
21241 bool arg2 = (bool) false ;
21242 wxShowEvent *result;
21243 PyObject * obj0 = 0 ;
21244 PyObject * obj1 = 0 ;
21245 char *kwnames[] = {
21246 (char *) "winid",(char *) "show", NULL
21247 };
21248
21249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
21250 if (obj0) {
21251 {
21252 arg1 = static_cast<int >(SWIG_As_int(obj0));
21253 if (SWIG_arg_fail(1)) SWIG_fail;
21254 }
21255 }
21256 if (obj1) {
21257 {
21258 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21259 if (SWIG_arg_fail(2)) SWIG_fail;
21260 }
21261 }
21262 {
21263 PyThreadState* __tstate = wxPyBeginAllowThreads();
21264 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
21265
21266 wxPyEndAllowThreads(__tstate);
21267 if (PyErr_Occurred()) SWIG_fail;
21268 }
21269 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
21270 return resultobj;
21271 fail:
21272 return NULL;
21273 }
21274
21275
21276 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21277 PyObject *resultobj = NULL;
21278 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21279 bool arg2 ;
21280 PyObject * obj0 = 0 ;
21281 PyObject * obj1 = 0 ;
21282 char *kwnames[] = {
21283 (char *) "self",(char *) "show", NULL
21284 };
21285
21286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
21287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21288 if (SWIG_arg_fail(1)) SWIG_fail;
21289 {
21290 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21291 if (SWIG_arg_fail(2)) SWIG_fail;
21292 }
21293 {
21294 PyThreadState* __tstate = wxPyBeginAllowThreads();
21295 (arg1)->SetShow(arg2);
21296
21297 wxPyEndAllowThreads(__tstate);
21298 if (PyErr_Occurred()) SWIG_fail;
21299 }
21300 Py_INCREF(Py_None); resultobj = Py_None;
21301 return resultobj;
21302 fail:
21303 return NULL;
21304 }
21305
21306
21307 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21308 PyObject *resultobj = NULL;
21309 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21310 bool result;
21311 PyObject * obj0 = 0 ;
21312 char *kwnames[] = {
21313 (char *) "self", NULL
21314 };
21315
21316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
21317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21318 if (SWIG_arg_fail(1)) SWIG_fail;
21319 {
21320 PyThreadState* __tstate = wxPyBeginAllowThreads();
21321 result = (bool)((wxShowEvent const *)arg1)->GetShow();
21322
21323 wxPyEndAllowThreads(__tstate);
21324 if (PyErr_Occurred()) SWIG_fail;
21325 }
21326 {
21327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21328 }
21329 return resultobj;
21330 fail:
21331 return NULL;
21332 }
21333
21334
21335 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
21336 PyObject *obj;
21337 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21338 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
21339 Py_INCREF(obj);
21340 return Py_BuildValue((char *)"");
21341 }
21342 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21343 PyObject *resultobj = NULL;
21344 int arg1 = (int) 0 ;
21345 bool arg2 = (bool) true ;
21346 wxIconizeEvent *result;
21347 PyObject * obj0 = 0 ;
21348 PyObject * obj1 = 0 ;
21349 char *kwnames[] = {
21350 (char *) "id",(char *) "iconized", NULL
21351 };
21352
21353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
21354 if (obj0) {
21355 {
21356 arg1 = static_cast<int >(SWIG_As_int(obj0));
21357 if (SWIG_arg_fail(1)) SWIG_fail;
21358 }
21359 }
21360 if (obj1) {
21361 {
21362 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21363 if (SWIG_arg_fail(2)) SWIG_fail;
21364 }
21365 }
21366 {
21367 PyThreadState* __tstate = wxPyBeginAllowThreads();
21368 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
21369
21370 wxPyEndAllowThreads(__tstate);
21371 if (PyErr_Occurred()) SWIG_fail;
21372 }
21373 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
21374 return resultobj;
21375 fail:
21376 return NULL;
21377 }
21378
21379
21380 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
21381 PyObject *resultobj = NULL;
21382 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
21383 bool result;
21384 PyObject * obj0 = 0 ;
21385 char *kwnames[] = {
21386 (char *) "self", NULL
21387 };
21388
21389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
21390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
21391 if (SWIG_arg_fail(1)) SWIG_fail;
21392 {
21393 PyThreadState* __tstate = wxPyBeginAllowThreads();
21394 result = (bool)(arg1)->Iconized();
21395
21396 wxPyEndAllowThreads(__tstate);
21397 if (PyErr_Occurred()) SWIG_fail;
21398 }
21399 {
21400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21401 }
21402 return resultobj;
21403 fail:
21404 return NULL;
21405 }
21406
21407
21408 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
21409 PyObject *obj;
21410 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21411 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
21412 Py_INCREF(obj);
21413 return Py_BuildValue((char *)"");
21414 }
21415 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21416 PyObject *resultobj = NULL;
21417 int arg1 = (int) 0 ;
21418 wxMaximizeEvent *result;
21419 PyObject * obj0 = 0 ;
21420 char *kwnames[] = {
21421 (char *) "id", NULL
21422 };
21423
21424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
21425 if (obj0) {
21426 {
21427 arg1 = static_cast<int >(SWIG_As_int(obj0));
21428 if (SWIG_arg_fail(1)) SWIG_fail;
21429 }
21430 }
21431 {
21432 PyThreadState* __tstate = wxPyBeginAllowThreads();
21433 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
21434
21435 wxPyEndAllowThreads(__tstate);
21436 if (PyErr_Occurred()) SWIG_fail;
21437 }
21438 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
21439 return resultobj;
21440 fail:
21441 return NULL;
21442 }
21443
21444
21445 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
21446 PyObject *obj;
21447 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21448 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
21449 Py_INCREF(obj);
21450 return Py_BuildValue((char *)"");
21451 }
21452 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21453 PyObject *resultobj = NULL;
21454 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21455 wxPoint result;
21456 PyObject * obj0 = 0 ;
21457 char *kwnames[] = {
21458 (char *) "self", NULL
21459 };
21460
21461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
21462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21463 if (SWIG_arg_fail(1)) SWIG_fail;
21464 {
21465 PyThreadState* __tstate = wxPyBeginAllowThreads();
21466 result = (arg1)->GetPosition();
21467
21468 wxPyEndAllowThreads(__tstate);
21469 if (PyErr_Occurred()) SWIG_fail;
21470 }
21471 {
21472 wxPoint * resultptr;
21473 resultptr = new wxPoint(static_cast<wxPoint & >(result));
21474 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
21475 }
21476 return resultobj;
21477 fail:
21478 return NULL;
21479 }
21480
21481
21482 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21483 PyObject *resultobj = NULL;
21484 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21485 int result;
21486 PyObject * obj0 = 0 ;
21487 char *kwnames[] = {
21488 (char *) "self", NULL
21489 };
21490
21491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
21492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21493 if (SWIG_arg_fail(1)) SWIG_fail;
21494 {
21495 PyThreadState* __tstate = wxPyBeginAllowThreads();
21496 result = (int)(arg1)->GetNumberOfFiles();
21497
21498 wxPyEndAllowThreads(__tstate);
21499 if (PyErr_Occurred()) SWIG_fail;
21500 }
21501 {
21502 resultobj = SWIG_From_int(static_cast<int >(result));
21503 }
21504 return resultobj;
21505 fail:
21506 return NULL;
21507 }
21508
21509
21510 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21511 PyObject *resultobj = NULL;
21512 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21513 PyObject *result;
21514 PyObject * obj0 = 0 ;
21515 char *kwnames[] = {
21516 (char *) "self", NULL
21517 };
21518
21519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
21520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21521 if (SWIG_arg_fail(1)) SWIG_fail;
21522 {
21523 PyThreadState* __tstate = wxPyBeginAllowThreads();
21524 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
21525
21526 wxPyEndAllowThreads(__tstate);
21527 if (PyErr_Occurred()) SWIG_fail;
21528 }
21529 resultobj = result;
21530 return resultobj;
21531 fail:
21532 return NULL;
21533 }
21534
21535
21536 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
21537 PyObject *obj;
21538 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21539 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
21540 Py_INCREF(obj);
21541 return Py_BuildValue((char *)"");
21542 }
21543 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21544 PyObject *resultobj = NULL;
21545 int arg1 = (int) 0 ;
21546 wxUpdateUIEvent *result;
21547 PyObject * obj0 = 0 ;
21548 char *kwnames[] = {
21549 (char *) "commandId", NULL
21550 };
21551
21552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
21553 if (obj0) {
21554 {
21555 arg1 = static_cast<int >(SWIG_As_int(obj0));
21556 if (SWIG_arg_fail(1)) SWIG_fail;
21557 }
21558 }
21559 {
21560 PyThreadState* __tstate = wxPyBeginAllowThreads();
21561 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
21562
21563 wxPyEndAllowThreads(__tstate);
21564 if (PyErr_Occurred()) SWIG_fail;
21565 }
21566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
21567 return resultobj;
21568 fail:
21569 return NULL;
21570 }
21571
21572
21573 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21574 PyObject *resultobj = NULL;
21575 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21576 bool result;
21577 PyObject * obj0 = 0 ;
21578 char *kwnames[] = {
21579 (char *) "self", NULL
21580 };
21581
21582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
21583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21584 if (SWIG_arg_fail(1)) SWIG_fail;
21585 {
21586 PyThreadState* __tstate = wxPyBeginAllowThreads();
21587 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
21588
21589 wxPyEndAllowThreads(__tstate);
21590 if (PyErr_Occurred()) SWIG_fail;
21591 }
21592 {
21593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21594 }
21595 return resultobj;
21596 fail:
21597 return NULL;
21598 }
21599
21600
21601 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21602 PyObject *resultobj = NULL;
21603 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21604 bool result;
21605 PyObject * obj0 = 0 ;
21606 char *kwnames[] = {
21607 (char *) "self", NULL
21608 };
21609
21610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
21611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21612 if (SWIG_arg_fail(1)) SWIG_fail;
21613 {
21614 PyThreadState* __tstate = wxPyBeginAllowThreads();
21615 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
21616
21617 wxPyEndAllowThreads(__tstate);
21618 if (PyErr_Occurred()) SWIG_fail;
21619 }
21620 {
21621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21622 }
21623 return resultobj;
21624 fail:
21625 return NULL;
21626 }
21627
21628
21629 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
21630 PyObject *resultobj = NULL;
21631 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21632 wxString result;
21633 PyObject * obj0 = 0 ;
21634 char *kwnames[] = {
21635 (char *) "self", NULL
21636 };
21637
21638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
21639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21640 if (SWIG_arg_fail(1)) SWIG_fail;
21641 {
21642 PyThreadState* __tstate = wxPyBeginAllowThreads();
21643 result = ((wxUpdateUIEvent const *)arg1)->GetText();
21644
21645 wxPyEndAllowThreads(__tstate);
21646 if (PyErr_Occurred()) SWIG_fail;
21647 }
21648 {
21649 #if wxUSE_UNICODE
21650 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21651 #else
21652 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21653 #endif
21654 }
21655 return resultobj;
21656 fail:
21657 return NULL;
21658 }
21659
21660
21661 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
21662 PyObject *resultobj = NULL;
21663 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21664 bool result;
21665 PyObject * obj0 = 0 ;
21666 char *kwnames[] = {
21667 (char *) "self", NULL
21668 };
21669
21670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
21671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21672 if (SWIG_arg_fail(1)) SWIG_fail;
21673 {
21674 PyThreadState* __tstate = wxPyBeginAllowThreads();
21675 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
21676
21677 wxPyEndAllowThreads(__tstate);
21678 if (PyErr_Occurred()) SWIG_fail;
21679 }
21680 {
21681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21682 }
21683 return resultobj;
21684 fail:
21685 return NULL;
21686 }
21687
21688
21689 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21690 PyObject *resultobj = NULL;
21691 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21692 bool result;
21693 PyObject * obj0 = 0 ;
21694 char *kwnames[] = {
21695 (char *) "self", NULL
21696 };
21697
21698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
21699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21700 if (SWIG_arg_fail(1)) SWIG_fail;
21701 {
21702 PyThreadState* __tstate = wxPyBeginAllowThreads();
21703 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
21704
21705 wxPyEndAllowThreads(__tstate);
21706 if (PyErr_Occurred()) SWIG_fail;
21707 }
21708 {
21709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21710 }
21711 return resultobj;
21712 fail:
21713 return NULL;
21714 }
21715
21716
21717 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21718 PyObject *resultobj = NULL;
21719 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21720 bool result;
21721 PyObject * obj0 = 0 ;
21722 char *kwnames[] = {
21723 (char *) "self", NULL
21724 };
21725
21726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
21727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21728 if (SWIG_arg_fail(1)) SWIG_fail;
21729 {
21730 PyThreadState* __tstate = wxPyBeginAllowThreads();
21731 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
21732
21733 wxPyEndAllowThreads(__tstate);
21734 if (PyErr_Occurred()) SWIG_fail;
21735 }
21736 {
21737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21738 }
21739 return resultobj;
21740 fail:
21741 return NULL;
21742 }
21743
21744
21745 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
21746 PyObject *resultobj = NULL;
21747 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21748 bool arg2 ;
21749 PyObject * obj0 = 0 ;
21750 PyObject * obj1 = 0 ;
21751 char *kwnames[] = {
21752 (char *) "self",(char *) "check", NULL
21753 };
21754
21755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
21756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21757 if (SWIG_arg_fail(1)) SWIG_fail;
21758 {
21759 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21760 if (SWIG_arg_fail(2)) SWIG_fail;
21761 }
21762 {
21763 PyThreadState* __tstate = wxPyBeginAllowThreads();
21764 (arg1)->Check(arg2);
21765
21766 wxPyEndAllowThreads(__tstate);
21767 if (PyErr_Occurred()) SWIG_fail;
21768 }
21769 Py_INCREF(Py_None); resultobj = Py_None;
21770 return resultobj;
21771 fail:
21772 return NULL;
21773 }
21774
21775
21776 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21777 PyObject *resultobj = NULL;
21778 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21779 bool arg2 ;
21780 PyObject * obj0 = 0 ;
21781 PyObject * obj1 = 0 ;
21782 char *kwnames[] = {
21783 (char *) "self",(char *) "enable", NULL
21784 };
21785
21786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21788 if (SWIG_arg_fail(1)) SWIG_fail;
21789 {
21790 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
21791 if (SWIG_arg_fail(2)) SWIG_fail;
21792 }
21793 {
21794 PyThreadState* __tstate = wxPyBeginAllowThreads();
21795 (arg1)->Enable(arg2);
21796
21797 wxPyEndAllowThreads(__tstate);
21798 if (PyErr_Occurred()) SWIG_fail;
21799 }
21800 Py_INCREF(Py_None); resultobj = Py_None;
21801 return resultobj;
21802 fail:
21803 return NULL;
21804 }
21805
21806
21807 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21808 PyObject *resultobj = NULL;
21809 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21810 wxString *arg2 = 0 ;
21811 bool temp2 = false ;
21812 PyObject * obj0 = 0 ;
21813 PyObject * obj1 = 0 ;
21814 char *kwnames[] = {
21815 (char *) "self",(char *) "text", NULL
21816 };
21817
21818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21820 if (SWIG_arg_fail(1)) SWIG_fail;
21821 {
21822 arg2 = wxString_in_helper(obj1);
21823 if (arg2 == NULL) SWIG_fail;
21824 temp2 = true;
21825 }
21826 {
21827 PyThreadState* __tstate = wxPyBeginAllowThreads();
21828 (arg1)->SetText((wxString const &)*arg2);
21829
21830 wxPyEndAllowThreads(__tstate);
21831 if (PyErr_Occurred()) SWIG_fail;
21832 }
21833 Py_INCREF(Py_None); resultobj = Py_None;
21834 {
21835 if (temp2)
21836 delete arg2;
21837 }
21838 return resultobj;
21839 fail:
21840 {
21841 if (temp2)
21842 delete arg2;
21843 }
21844 return NULL;
21845 }
21846
21847
21848 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21849 PyObject *resultobj = NULL;
21850 long arg1 ;
21851 PyObject * obj0 = 0 ;
21852 char *kwnames[] = {
21853 (char *) "updateInterval", NULL
21854 };
21855
21856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21857 {
21858 arg1 = static_cast<long >(SWIG_As_long(obj0));
21859 if (SWIG_arg_fail(1)) SWIG_fail;
21860 }
21861 {
21862 PyThreadState* __tstate = wxPyBeginAllowThreads();
21863 wxUpdateUIEvent::SetUpdateInterval(arg1);
21864
21865 wxPyEndAllowThreads(__tstate);
21866 if (PyErr_Occurred()) SWIG_fail;
21867 }
21868 Py_INCREF(Py_None); resultobj = Py_None;
21869 return resultobj;
21870 fail:
21871 return NULL;
21872 }
21873
21874
21875 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21876 PyObject *resultobj = NULL;
21877 long result;
21878 char *kwnames[] = {
21879 NULL
21880 };
21881
21882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21883 {
21884 PyThreadState* __tstate = wxPyBeginAllowThreads();
21885 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21886
21887 wxPyEndAllowThreads(__tstate);
21888 if (PyErr_Occurred()) SWIG_fail;
21889 }
21890 {
21891 resultobj = SWIG_From_long(static_cast<long >(result));
21892 }
21893 return resultobj;
21894 fail:
21895 return NULL;
21896 }
21897
21898
21899 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21900 PyObject *resultobj = NULL;
21901 wxWindow *arg1 = (wxWindow *) 0 ;
21902 bool result;
21903 PyObject * obj0 = 0 ;
21904 char *kwnames[] = {
21905 (char *) "win", NULL
21906 };
21907
21908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21910 if (SWIG_arg_fail(1)) SWIG_fail;
21911 {
21912 PyThreadState* __tstate = wxPyBeginAllowThreads();
21913 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21914
21915 wxPyEndAllowThreads(__tstate);
21916 if (PyErr_Occurred()) SWIG_fail;
21917 }
21918 {
21919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21920 }
21921 return resultobj;
21922 fail:
21923 return NULL;
21924 }
21925
21926
21927 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21928 PyObject *resultobj = NULL;
21929 char *kwnames[] = {
21930 NULL
21931 };
21932
21933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21934 {
21935 PyThreadState* __tstate = wxPyBeginAllowThreads();
21936 wxUpdateUIEvent::ResetUpdateTime();
21937
21938 wxPyEndAllowThreads(__tstate);
21939 if (PyErr_Occurred()) SWIG_fail;
21940 }
21941 Py_INCREF(Py_None); resultobj = Py_None;
21942 return resultobj;
21943 fail:
21944 return NULL;
21945 }
21946
21947
21948 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21949 PyObject *resultobj = NULL;
21950 wxUpdateUIMode arg1 ;
21951 PyObject * obj0 = 0 ;
21952 char *kwnames[] = {
21953 (char *) "mode", NULL
21954 };
21955
21956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21957 {
21958 arg1 = static_cast<wxUpdateUIMode >(SWIG_As_int(obj0));
21959 if (SWIG_arg_fail(1)) SWIG_fail;
21960 }
21961 {
21962 PyThreadState* __tstate = wxPyBeginAllowThreads();
21963 wxUpdateUIEvent::SetMode(arg1);
21964
21965 wxPyEndAllowThreads(__tstate);
21966 if (PyErr_Occurred()) SWIG_fail;
21967 }
21968 Py_INCREF(Py_None); resultobj = Py_None;
21969 return resultobj;
21970 fail:
21971 return NULL;
21972 }
21973
21974
21975 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21976 PyObject *resultobj = NULL;
21977 wxUpdateUIMode result;
21978 char *kwnames[] = {
21979 NULL
21980 };
21981
21982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21983 {
21984 PyThreadState* __tstate = wxPyBeginAllowThreads();
21985 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21986
21987 wxPyEndAllowThreads(__tstate);
21988 if (PyErr_Occurred()) SWIG_fail;
21989 }
21990 resultobj = SWIG_From_int((result));
21991 return resultobj;
21992 fail:
21993 return NULL;
21994 }
21995
21996
21997 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21998 PyObject *obj;
21999 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22000 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
22001 Py_INCREF(obj);
22002 return Py_BuildValue((char *)"");
22003 }
22004 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22005 PyObject *resultobj = NULL;
22006 wxSysColourChangedEvent *result;
22007 char *kwnames[] = {
22008 NULL
22009 };
22010
22011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
22012 {
22013 PyThreadState* __tstate = wxPyBeginAllowThreads();
22014 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
22015
22016 wxPyEndAllowThreads(__tstate);
22017 if (PyErr_Occurred()) SWIG_fail;
22018 }
22019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
22020 return resultobj;
22021 fail:
22022 return NULL;
22023 }
22024
22025
22026 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
22027 PyObject *obj;
22028 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22029 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
22030 Py_INCREF(obj);
22031 return Py_BuildValue((char *)"");
22032 }
22033 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22034 PyObject *resultobj = NULL;
22035 int arg1 = (int) 0 ;
22036 wxWindow *arg2 = (wxWindow *) NULL ;
22037 wxMouseCaptureChangedEvent *result;
22038 PyObject * obj0 = 0 ;
22039 PyObject * obj1 = 0 ;
22040 char *kwnames[] = {
22041 (char *) "winid",(char *) "gainedCapture", NULL
22042 };
22043
22044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
22045 if (obj0) {
22046 {
22047 arg1 = static_cast<int >(SWIG_As_int(obj0));
22048 if (SWIG_arg_fail(1)) SWIG_fail;
22049 }
22050 }
22051 if (obj1) {
22052 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22053 if (SWIG_arg_fail(2)) SWIG_fail;
22054 }
22055 {
22056 PyThreadState* __tstate = wxPyBeginAllowThreads();
22057 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
22058
22059 wxPyEndAllowThreads(__tstate);
22060 if (PyErr_Occurred()) SWIG_fail;
22061 }
22062 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
22063 return resultobj;
22064 fail:
22065 return NULL;
22066 }
22067
22068
22069 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22070 PyObject *resultobj = NULL;
22071 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
22072 wxWindow *result;
22073 PyObject * obj0 = 0 ;
22074 char *kwnames[] = {
22075 (char *) "self", NULL
22076 };
22077
22078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
22079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22080 if (SWIG_arg_fail(1)) SWIG_fail;
22081 {
22082 PyThreadState* __tstate = wxPyBeginAllowThreads();
22083 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
22084
22085 wxPyEndAllowThreads(__tstate);
22086 if (PyErr_Occurred()) SWIG_fail;
22087 }
22088 {
22089 resultobj = wxPyMake_wxObject(result, (bool)0);
22090 }
22091 return resultobj;
22092 fail:
22093 return NULL;
22094 }
22095
22096
22097 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
22098 PyObject *obj;
22099 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22100 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
22101 Py_INCREF(obj);
22102 return Py_BuildValue((char *)"");
22103 }
22104 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22105 PyObject *resultobj = NULL;
22106 wxDisplayChangedEvent *result;
22107 char *kwnames[] = {
22108 NULL
22109 };
22110
22111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
22112 {
22113 PyThreadState* __tstate = wxPyBeginAllowThreads();
22114 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
22115
22116 wxPyEndAllowThreads(__tstate);
22117 if (PyErr_Occurred()) SWIG_fail;
22118 }
22119 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
22120 return resultobj;
22121 fail:
22122 return NULL;
22123 }
22124
22125
22126 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
22127 PyObject *obj;
22128 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22129 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
22130 Py_INCREF(obj);
22131 return Py_BuildValue((char *)"");
22132 }
22133 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22134 PyObject *resultobj = NULL;
22135 int arg1 = (int) 0 ;
22136 wxPaletteChangedEvent *result;
22137 PyObject * obj0 = 0 ;
22138 char *kwnames[] = {
22139 (char *) "id", NULL
22140 };
22141
22142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
22143 if (obj0) {
22144 {
22145 arg1 = static_cast<int >(SWIG_As_int(obj0));
22146 if (SWIG_arg_fail(1)) SWIG_fail;
22147 }
22148 }
22149 {
22150 PyThreadState* __tstate = wxPyBeginAllowThreads();
22151 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
22152
22153 wxPyEndAllowThreads(__tstate);
22154 if (PyErr_Occurred()) SWIG_fail;
22155 }
22156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
22157 return resultobj;
22158 fail:
22159 return NULL;
22160 }
22161
22162
22163 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22164 PyObject *resultobj = NULL;
22165 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22166 wxWindow *arg2 = (wxWindow *) 0 ;
22167 PyObject * obj0 = 0 ;
22168 PyObject * obj1 = 0 ;
22169 char *kwnames[] = {
22170 (char *) "self",(char *) "win", NULL
22171 };
22172
22173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
22174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22175 if (SWIG_arg_fail(1)) SWIG_fail;
22176 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22177 if (SWIG_arg_fail(2)) SWIG_fail;
22178 {
22179 PyThreadState* __tstate = wxPyBeginAllowThreads();
22180 (arg1)->SetChangedWindow(arg2);
22181
22182 wxPyEndAllowThreads(__tstate);
22183 if (PyErr_Occurred()) SWIG_fail;
22184 }
22185 Py_INCREF(Py_None); resultobj = Py_None;
22186 return resultobj;
22187 fail:
22188 return NULL;
22189 }
22190
22191
22192 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22193 PyObject *resultobj = NULL;
22194 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
22195 wxWindow *result;
22196 PyObject * obj0 = 0 ;
22197 char *kwnames[] = {
22198 (char *) "self", NULL
22199 };
22200
22201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
22202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
22203 if (SWIG_arg_fail(1)) SWIG_fail;
22204 {
22205 PyThreadState* __tstate = wxPyBeginAllowThreads();
22206 result = (wxWindow *)(arg1)->GetChangedWindow();
22207
22208 wxPyEndAllowThreads(__tstate);
22209 if (PyErr_Occurred()) SWIG_fail;
22210 }
22211 {
22212 resultobj = wxPyMake_wxObject(result, (bool)0);
22213 }
22214 return resultobj;
22215 fail:
22216 return NULL;
22217 }
22218
22219
22220 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
22221 PyObject *obj;
22222 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22223 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
22224 Py_INCREF(obj);
22225 return Py_BuildValue((char *)"");
22226 }
22227 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22228 PyObject *resultobj = NULL;
22229 int arg1 = (int) 0 ;
22230 wxQueryNewPaletteEvent *result;
22231 PyObject * obj0 = 0 ;
22232 char *kwnames[] = {
22233 (char *) "winid", NULL
22234 };
22235
22236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
22237 if (obj0) {
22238 {
22239 arg1 = static_cast<int >(SWIG_As_int(obj0));
22240 if (SWIG_arg_fail(1)) SWIG_fail;
22241 }
22242 }
22243 {
22244 PyThreadState* __tstate = wxPyBeginAllowThreads();
22245 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
22246
22247 wxPyEndAllowThreads(__tstate);
22248 if (PyErr_Occurred()) SWIG_fail;
22249 }
22250 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
22251 return resultobj;
22252 fail:
22253 return NULL;
22254 }
22255
22256
22257 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22258 PyObject *resultobj = NULL;
22259 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22260 bool arg2 ;
22261 PyObject * obj0 = 0 ;
22262 PyObject * obj1 = 0 ;
22263 char *kwnames[] = {
22264 (char *) "self",(char *) "realized", NULL
22265 };
22266
22267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
22268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22269 if (SWIG_arg_fail(1)) SWIG_fail;
22270 {
22271 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22272 if (SWIG_arg_fail(2)) SWIG_fail;
22273 }
22274 {
22275 PyThreadState* __tstate = wxPyBeginAllowThreads();
22276 (arg1)->SetPaletteRealized(arg2);
22277
22278 wxPyEndAllowThreads(__tstate);
22279 if (PyErr_Occurred()) SWIG_fail;
22280 }
22281 Py_INCREF(Py_None); resultobj = Py_None;
22282 return resultobj;
22283 fail:
22284 return NULL;
22285 }
22286
22287
22288 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22289 PyObject *resultobj = NULL;
22290 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22291 bool result;
22292 PyObject * obj0 = 0 ;
22293 char *kwnames[] = {
22294 (char *) "self", NULL
22295 };
22296
22297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
22298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22299 if (SWIG_arg_fail(1)) SWIG_fail;
22300 {
22301 PyThreadState* __tstate = wxPyBeginAllowThreads();
22302 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
22303
22304 wxPyEndAllowThreads(__tstate);
22305 if (PyErr_Occurred()) SWIG_fail;
22306 }
22307 {
22308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22309 }
22310 return resultobj;
22311 fail:
22312 return NULL;
22313 }
22314
22315
22316 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
22317 PyObject *obj;
22318 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22319 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
22320 Py_INCREF(obj);
22321 return Py_BuildValue((char *)"");
22322 }
22323 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22324 PyObject *resultobj = NULL;
22325 wxNavigationKeyEvent *result;
22326 char *kwnames[] = {
22327 NULL
22328 };
22329
22330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
22331 {
22332 PyThreadState* __tstate = wxPyBeginAllowThreads();
22333 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
22334
22335 wxPyEndAllowThreads(__tstate);
22336 if (PyErr_Occurred()) SWIG_fail;
22337 }
22338 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
22339 return resultobj;
22340 fail:
22341 return NULL;
22342 }
22343
22344
22345 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22346 PyObject *resultobj = NULL;
22347 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22348 bool result;
22349 PyObject * obj0 = 0 ;
22350 char *kwnames[] = {
22351 (char *) "self", NULL
22352 };
22353
22354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
22355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22356 if (SWIG_arg_fail(1)) SWIG_fail;
22357 {
22358 PyThreadState* __tstate = wxPyBeginAllowThreads();
22359 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
22360
22361 wxPyEndAllowThreads(__tstate);
22362 if (PyErr_Occurred()) SWIG_fail;
22363 }
22364 {
22365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22366 }
22367 return resultobj;
22368 fail:
22369 return NULL;
22370 }
22371
22372
22373 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22374 PyObject *resultobj = NULL;
22375 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22376 bool arg2 ;
22377 PyObject * obj0 = 0 ;
22378 PyObject * obj1 = 0 ;
22379 char *kwnames[] = {
22380 (char *) "self",(char *) "forward", NULL
22381 };
22382
22383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
22384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22385 if (SWIG_arg_fail(1)) SWIG_fail;
22386 {
22387 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22388 if (SWIG_arg_fail(2)) SWIG_fail;
22389 }
22390 {
22391 PyThreadState* __tstate = wxPyBeginAllowThreads();
22392 (arg1)->SetDirection(arg2);
22393
22394 wxPyEndAllowThreads(__tstate);
22395 if (PyErr_Occurred()) SWIG_fail;
22396 }
22397 Py_INCREF(Py_None); resultobj = Py_None;
22398 return resultobj;
22399 fail:
22400 return NULL;
22401 }
22402
22403
22404 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22405 PyObject *resultobj = NULL;
22406 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22407 bool result;
22408 PyObject * obj0 = 0 ;
22409 char *kwnames[] = {
22410 (char *) "self", NULL
22411 };
22412
22413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
22414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22415 if (SWIG_arg_fail(1)) SWIG_fail;
22416 {
22417 PyThreadState* __tstate = wxPyBeginAllowThreads();
22418 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
22419
22420 wxPyEndAllowThreads(__tstate);
22421 if (PyErr_Occurred()) SWIG_fail;
22422 }
22423 {
22424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22425 }
22426 return resultobj;
22427 fail:
22428 return NULL;
22429 }
22430
22431
22432 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22433 PyObject *resultobj = NULL;
22434 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22435 bool arg2 ;
22436 PyObject * obj0 = 0 ;
22437 PyObject * obj1 = 0 ;
22438 char *kwnames[] = {
22439 (char *) "self",(char *) "ischange", NULL
22440 };
22441
22442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
22443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22444 if (SWIG_arg_fail(1)) SWIG_fail;
22445 {
22446 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22447 if (SWIG_arg_fail(2)) SWIG_fail;
22448 }
22449 {
22450 PyThreadState* __tstate = wxPyBeginAllowThreads();
22451 (arg1)->SetWindowChange(arg2);
22452
22453 wxPyEndAllowThreads(__tstate);
22454 if (PyErr_Occurred()) SWIG_fail;
22455 }
22456 Py_INCREF(Py_None); resultobj = Py_None;
22457 return resultobj;
22458 fail:
22459 return NULL;
22460 }
22461
22462
22463 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22464 PyObject *resultobj = NULL;
22465 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22466 bool result;
22467 PyObject * obj0 = 0 ;
22468 char *kwnames[] = {
22469 (char *) "self", NULL
22470 };
22471
22472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
22473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22474 if (SWIG_arg_fail(1)) SWIG_fail;
22475 {
22476 PyThreadState* __tstate = wxPyBeginAllowThreads();
22477 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
22478
22479 wxPyEndAllowThreads(__tstate);
22480 if (PyErr_Occurred()) SWIG_fail;
22481 }
22482 {
22483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22484 }
22485 return resultobj;
22486 fail:
22487 return NULL;
22488 }
22489
22490
22491 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22492 PyObject *resultobj = NULL;
22493 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22494 bool arg2 ;
22495 PyObject * obj0 = 0 ;
22496 PyObject * obj1 = 0 ;
22497 char *kwnames[] = {
22498 (char *) "self",(char *) "bIs", NULL
22499 };
22500
22501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
22502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22503 if (SWIG_arg_fail(1)) SWIG_fail;
22504 {
22505 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22506 if (SWIG_arg_fail(2)) SWIG_fail;
22507 }
22508 {
22509 PyThreadState* __tstate = wxPyBeginAllowThreads();
22510 (arg1)->SetFromTab(arg2);
22511
22512 wxPyEndAllowThreads(__tstate);
22513 if (PyErr_Occurred()) SWIG_fail;
22514 }
22515 Py_INCREF(Py_None); resultobj = Py_None;
22516 return resultobj;
22517 fail:
22518 return NULL;
22519 }
22520
22521
22522 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
22523 PyObject *resultobj = NULL;
22524 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22525 long arg2 ;
22526 PyObject * obj0 = 0 ;
22527 PyObject * obj1 = 0 ;
22528 char *kwnames[] = {
22529 (char *) "self",(char *) "flags", NULL
22530 };
22531
22532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
22533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22534 if (SWIG_arg_fail(1)) SWIG_fail;
22535 {
22536 arg2 = static_cast<long >(SWIG_As_long(obj1));
22537 if (SWIG_arg_fail(2)) SWIG_fail;
22538 }
22539 {
22540 PyThreadState* __tstate = wxPyBeginAllowThreads();
22541 (arg1)->SetFlags(arg2);
22542
22543 wxPyEndAllowThreads(__tstate);
22544 if (PyErr_Occurred()) SWIG_fail;
22545 }
22546 Py_INCREF(Py_None); resultobj = Py_None;
22547 return resultobj;
22548 fail:
22549 return NULL;
22550 }
22551
22552
22553 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22554 PyObject *resultobj = NULL;
22555 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22556 wxWindow *result;
22557 PyObject * obj0 = 0 ;
22558 char *kwnames[] = {
22559 (char *) "self", NULL
22560 };
22561
22562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
22563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22564 if (SWIG_arg_fail(1)) SWIG_fail;
22565 {
22566 PyThreadState* __tstate = wxPyBeginAllowThreads();
22567 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
22568
22569 wxPyEndAllowThreads(__tstate);
22570 if (PyErr_Occurred()) SWIG_fail;
22571 }
22572 {
22573 resultobj = wxPyMake_wxObject(result, (bool)0);
22574 }
22575 return resultobj;
22576 fail:
22577 return NULL;
22578 }
22579
22580
22581 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22582 PyObject *resultobj = NULL;
22583 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22584 wxWindow *arg2 = (wxWindow *) 0 ;
22585 PyObject * obj0 = 0 ;
22586 PyObject * obj1 = 0 ;
22587 char *kwnames[] = {
22588 (char *) "self",(char *) "win", NULL
22589 };
22590
22591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
22592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22593 if (SWIG_arg_fail(1)) SWIG_fail;
22594 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22595 if (SWIG_arg_fail(2)) SWIG_fail;
22596 {
22597 PyThreadState* __tstate = wxPyBeginAllowThreads();
22598 (arg1)->SetCurrentFocus(arg2);
22599
22600 wxPyEndAllowThreads(__tstate);
22601 if (PyErr_Occurred()) SWIG_fail;
22602 }
22603 Py_INCREF(Py_None); resultobj = Py_None;
22604 return resultobj;
22605 fail:
22606 return NULL;
22607 }
22608
22609
22610 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
22611 PyObject *obj;
22612 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22613 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
22614 Py_INCREF(obj);
22615 return Py_BuildValue((char *)"");
22616 }
22617 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22618 PyObject *resultobj = NULL;
22619 wxWindow *arg1 = (wxWindow *) NULL ;
22620 wxWindowCreateEvent *result;
22621 PyObject * obj0 = 0 ;
22622 char *kwnames[] = {
22623 (char *) "win", NULL
22624 };
22625
22626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
22627 if (obj0) {
22628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22629 if (SWIG_arg_fail(1)) SWIG_fail;
22630 }
22631 {
22632 PyThreadState* __tstate = wxPyBeginAllowThreads();
22633 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
22634
22635 wxPyEndAllowThreads(__tstate);
22636 if (PyErr_Occurred()) SWIG_fail;
22637 }
22638 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
22639 return resultobj;
22640 fail:
22641 return NULL;
22642 }
22643
22644
22645 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22646 PyObject *resultobj = NULL;
22647 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
22648 wxWindow *result;
22649 PyObject * obj0 = 0 ;
22650 char *kwnames[] = {
22651 (char *) "self", NULL
22652 };
22653
22654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
22655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
22656 if (SWIG_arg_fail(1)) SWIG_fail;
22657 {
22658 PyThreadState* __tstate = wxPyBeginAllowThreads();
22659 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
22660
22661 wxPyEndAllowThreads(__tstate);
22662 if (PyErr_Occurred()) SWIG_fail;
22663 }
22664 {
22665 resultobj = wxPyMake_wxObject(result, (bool)0);
22666 }
22667 return resultobj;
22668 fail:
22669 return NULL;
22670 }
22671
22672
22673 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
22674 PyObject *obj;
22675 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22676 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
22677 Py_INCREF(obj);
22678 return Py_BuildValue((char *)"");
22679 }
22680 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22681 PyObject *resultobj = NULL;
22682 wxWindow *arg1 = (wxWindow *) NULL ;
22683 wxWindowDestroyEvent *result;
22684 PyObject * obj0 = 0 ;
22685 char *kwnames[] = {
22686 (char *) "win", NULL
22687 };
22688
22689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
22690 if (obj0) {
22691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22692 if (SWIG_arg_fail(1)) SWIG_fail;
22693 }
22694 {
22695 PyThreadState* __tstate = wxPyBeginAllowThreads();
22696 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
22697
22698 wxPyEndAllowThreads(__tstate);
22699 if (PyErr_Occurred()) SWIG_fail;
22700 }
22701 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
22702 return resultobj;
22703 fail:
22704 return NULL;
22705 }
22706
22707
22708 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22709 PyObject *resultobj = NULL;
22710 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
22711 wxWindow *result;
22712 PyObject * obj0 = 0 ;
22713 char *kwnames[] = {
22714 (char *) "self", NULL
22715 };
22716
22717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
22718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
22719 if (SWIG_arg_fail(1)) SWIG_fail;
22720 {
22721 PyThreadState* __tstate = wxPyBeginAllowThreads();
22722 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
22723
22724 wxPyEndAllowThreads(__tstate);
22725 if (PyErr_Occurred()) SWIG_fail;
22726 }
22727 {
22728 resultobj = wxPyMake_wxObject(result, (bool)0);
22729 }
22730 return resultobj;
22731 fail:
22732 return NULL;
22733 }
22734
22735
22736 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
22737 PyObject *obj;
22738 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22739 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
22740 Py_INCREF(obj);
22741 return Py_BuildValue((char *)"");
22742 }
22743 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22744 PyObject *resultobj = NULL;
22745 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22746 int arg2 = (int) 0 ;
22747 wxPoint const &arg3_defvalue = wxDefaultPosition ;
22748 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
22749 wxContextMenuEvent *result;
22750 wxPoint temp3 ;
22751 PyObject * obj0 = 0 ;
22752 PyObject * obj1 = 0 ;
22753 PyObject * obj2 = 0 ;
22754 char *kwnames[] = {
22755 (char *) "type",(char *) "winid",(char *) "pt", NULL
22756 };
22757
22758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22759 if (obj0) {
22760 {
22761 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
22762 if (SWIG_arg_fail(1)) SWIG_fail;
22763 }
22764 }
22765 if (obj1) {
22766 {
22767 arg2 = static_cast<int >(SWIG_As_int(obj1));
22768 if (SWIG_arg_fail(2)) SWIG_fail;
22769 }
22770 }
22771 if (obj2) {
22772 {
22773 arg3 = &temp3;
22774 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22775 }
22776 }
22777 {
22778 PyThreadState* __tstate = wxPyBeginAllowThreads();
22779 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22780
22781 wxPyEndAllowThreads(__tstate);
22782 if (PyErr_Occurred()) SWIG_fail;
22783 }
22784 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22785 return resultobj;
22786 fail:
22787 return NULL;
22788 }
22789
22790
22791 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22792 PyObject *resultobj = NULL;
22793 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22794 wxPoint *result;
22795 PyObject * obj0 = 0 ;
22796 char *kwnames[] = {
22797 (char *) "self", NULL
22798 };
22799
22800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22802 if (SWIG_arg_fail(1)) SWIG_fail;
22803 {
22804 PyThreadState* __tstate = wxPyBeginAllowThreads();
22805 {
22806 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22807 result = (wxPoint *) &_result_ref;
22808 }
22809
22810 wxPyEndAllowThreads(__tstate);
22811 if (PyErr_Occurred()) SWIG_fail;
22812 }
22813 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22814 return resultobj;
22815 fail:
22816 return NULL;
22817 }
22818
22819
22820 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22821 PyObject *resultobj = NULL;
22822 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22823 wxPoint *arg2 = 0 ;
22824 wxPoint temp2 ;
22825 PyObject * obj0 = 0 ;
22826 PyObject * obj1 = 0 ;
22827 char *kwnames[] = {
22828 (char *) "self",(char *) "pos", NULL
22829 };
22830
22831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22833 if (SWIG_arg_fail(1)) SWIG_fail;
22834 {
22835 arg2 = &temp2;
22836 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22837 }
22838 {
22839 PyThreadState* __tstate = wxPyBeginAllowThreads();
22840 (arg1)->SetPosition((wxPoint const &)*arg2);
22841
22842 wxPyEndAllowThreads(__tstate);
22843 if (PyErr_Occurred()) SWIG_fail;
22844 }
22845 Py_INCREF(Py_None); resultobj = Py_None;
22846 return resultobj;
22847 fail:
22848 return NULL;
22849 }
22850
22851
22852 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22853 PyObject *obj;
22854 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22855 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22856 Py_INCREF(obj);
22857 return Py_BuildValue((char *)"");
22858 }
22859 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22860 PyObject *resultobj = NULL;
22861 wxIdleEvent *result;
22862 char *kwnames[] = {
22863 NULL
22864 };
22865
22866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22867 {
22868 PyThreadState* __tstate = wxPyBeginAllowThreads();
22869 result = (wxIdleEvent *)new wxIdleEvent();
22870
22871 wxPyEndAllowThreads(__tstate);
22872 if (PyErr_Occurred()) SWIG_fail;
22873 }
22874 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22875 return resultobj;
22876 fail:
22877 return NULL;
22878 }
22879
22880
22881 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22882 PyObject *resultobj = NULL;
22883 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22884 bool arg2 = (bool) true ;
22885 PyObject * obj0 = 0 ;
22886 PyObject * obj1 = 0 ;
22887 char *kwnames[] = {
22888 (char *) "self",(char *) "needMore", NULL
22889 };
22890
22891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22893 if (SWIG_arg_fail(1)) SWIG_fail;
22894 if (obj1) {
22895 {
22896 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
22897 if (SWIG_arg_fail(2)) SWIG_fail;
22898 }
22899 }
22900 {
22901 PyThreadState* __tstate = wxPyBeginAllowThreads();
22902 (arg1)->RequestMore(arg2);
22903
22904 wxPyEndAllowThreads(__tstate);
22905 if (PyErr_Occurred()) SWIG_fail;
22906 }
22907 Py_INCREF(Py_None); resultobj = Py_None;
22908 return resultobj;
22909 fail:
22910 return NULL;
22911 }
22912
22913
22914 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22915 PyObject *resultobj = NULL;
22916 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22917 bool result;
22918 PyObject * obj0 = 0 ;
22919 char *kwnames[] = {
22920 (char *) "self", NULL
22921 };
22922
22923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22925 if (SWIG_arg_fail(1)) SWIG_fail;
22926 {
22927 PyThreadState* __tstate = wxPyBeginAllowThreads();
22928 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22929
22930 wxPyEndAllowThreads(__tstate);
22931 if (PyErr_Occurred()) SWIG_fail;
22932 }
22933 {
22934 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22935 }
22936 return resultobj;
22937 fail:
22938 return NULL;
22939 }
22940
22941
22942 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22943 PyObject *resultobj = NULL;
22944 wxIdleMode arg1 ;
22945 PyObject * obj0 = 0 ;
22946 char *kwnames[] = {
22947 (char *) "mode", NULL
22948 };
22949
22950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22951 {
22952 arg1 = static_cast<wxIdleMode >(SWIG_As_int(obj0));
22953 if (SWIG_arg_fail(1)) SWIG_fail;
22954 }
22955 {
22956 PyThreadState* __tstate = wxPyBeginAllowThreads();
22957 wxIdleEvent::SetMode(arg1);
22958
22959 wxPyEndAllowThreads(__tstate);
22960 if (PyErr_Occurred()) SWIG_fail;
22961 }
22962 Py_INCREF(Py_None); resultobj = Py_None;
22963 return resultobj;
22964 fail:
22965 return NULL;
22966 }
22967
22968
22969 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22970 PyObject *resultobj = NULL;
22971 wxIdleMode result;
22972 char *kwnames[] = {
22973 NULL
22974 };
22975
22976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22977 {
22978 PyThreadState* __tstate = wxPyBeginAllowThreads();
22979 result = (wxIdleMode)wxIdleEvent::GetMode();
22980
22981 wxPyEndAllowThreads(__tstate);
22982 if (PyErr_Occurred()) SWIG_fail;
22983 }
22984 resultobj = SWIG_From_int((result));
22985 return resultobj;
22986 fail:
22987 return NULL;
22988 }
22989
22990
22991 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22992 PyObject *resultobj = NULL;
22993 wxWindow *arg1 = (wxWindow *) 0 ;
22994 bool result;
22995 PyObject * obj0 = 0 ;
22996 char *kwnames[] = {
22997 (char *) "win", NULL
22998 };
22999
23000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
23001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23002 if (SWIG_arg_fail(1)) SWIG_fail;
23003 {
23004 PyThreadState* __tstate = wxPyBeginAllowThreads();
23005 result = (bool)wxIdleEvent::CanSend(arg1);
23006
23007 wxPyEndAllowThreads(__tstate);
23008 if (PyErr_Occurred()) SWIG_fail;
23009 }
23010 {
23011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23012 }
23013 return resultobj;
23014 fail:
23015 return NULL;
23016 }
23017
23018
23019 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
23020 PyObject *obj;
23021 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23022 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
23023 Py_INCREF(obj);
23024 return Py_BuildValue((char *)"");
23025 }
23026 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23027 PyObject *resultobj = NULL;
23028 int arg1 = (int) 0 ;
23029 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
23030 wxPyEvent *result;
23031 PyObject * obj0 = 0 ;
23032 PyObject * obj1 = 0 ;
23033 char *kwnames[] = {
23034 (char *) "winid",(char *) "eventType", NULL
23035 };
23036
23037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
23038 if (obj0) {
23039 {
23040 arg1 = static_cast<int >(SWIG_As_int(obj0));
23041 if (SWIG_arg_fail(1)) SWIG_fail;
23042 }
23043 }
23044 if (obj1) {
23045 {
23046 arg2 = static_cast<wxEventType >(SWIG_As_int(obj1));
23047 if (SWIG_arg_fail(2)) SWIG_fail;
23048 }
23049 }
23050 {
23051 PyThreadState* __tstate = wxPyBeginAllowThreads();
23052 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
23053
23054 wxPyEndAllowThreads(__tstate);
23055 if (PyErr_Occurred()) SWIG_fail;
23056 }
23057 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
23058 return resultobj;
23059 fail:
23060 return NULL;
23061 }
23062
23063
23064 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23065 PyObject *resultobj = NULL;
23066 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23067 PyObject * obj0 = 0 ;
23068 char *kwnames[] = {
23069 (char *) "self", NULL
23070 };
23071
23072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
23073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23074 if (SWIG_arg_fail(1)) SWIG_fail;
23075 {
23076 PyThreadState* __tstate = wxPyBeginAllowThreads();
23077 delete arg1;
23078
23079 wxPyEndAllowThreads(__tstate);
23080 if (PyErr_Occurred()) SWIG_fail;
23081 }
23082 Py_INCREF(Py_None); resultobj = Py_None;
23083 return resultobj;
23084 fail:
23085 return NULL;
23086 }
23087
23088
23089 static PyObject *_wrap_PyEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23090 PyObject *resultobj = NULL;
23091 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23092 PyObject *arg2 = (PyObject *) 0 ;
23093 PyObject * obj0 = 0 ;
23094 PyObject * obj1 = 0 ;
23095 char *kwnames[] = {
23096 (char *) "self",(char *) "self", NULL
23097 };
23098
23099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23101 if (SWIG_arg_fail(1)) SWIG_fail;
23102 arg2 = obj1;
23103 {
23104 PyThreadState* __tstate = wxPyBeginAllowThreads();
23105 (arg1)->SetSelf(arg2);
23106
23107 wxPyEndAllowThreads(__tstate);
23108 if (PyErr_Occurred()) SWIG_fail;
23109 }
23110 Py_INCREF(Py_None); resultobj = Py_None;
23111 return resultobj;
23112 fail:
23113 return NULL;
23114 }
23115
23116
23117 static PyObject *_wrap_PyEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23118 PyObject *resultobj = NULL;
23119 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
23120 PyObject *result;
23121 PyObject * obj0 = 0 ;
23122 char *kwnames[] = {
23123 (char *) "self", NULL
23124 };
23125
23126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent__GetSelf",kwnames,&obj0)) goto fail;
23127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
23128 if (SWIG_arg_fail(1)) SWIG_fail;
23129 {
23130 PyThreadState* __tstate = wxPyBeginAllowThreads();
23131 result = (PyObject *)(arg1)->GetSelf();
23132
23133 wxPyEndAllowThreads(__tstate);
23134 if (PyErr_Occurred()) SWIG_fail;
23135 }
23136 resultobj = result;
23137 return resultobj;
23138 fail:
23139 return NULL;
23140 }
23141
23142
23143 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
23144 PyObject *obj;
23145 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23146 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
23147 Py_INCREF(obj);
23148 return Py_BuildValue((char *)"");
23149 }
23150 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23151 PyObject *resultobj = NULL;
23152 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23153 int arg2 = (int) 0 ;
23154 wxPyCommandEvent *result;
23155 PyObject * obj0 = 0 ;
23156 PyObject * obj1 = 0 ;
23157 char *kwnames[] = {
23158 (char *) "eventType",(char *) "id", NULL
23159 };
23160
23161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
23162 if (obj0) {
23163 {
23164 arg1 = static_cast<wxEventType >(SWIG_As_int(obj0));
23165 if (SWIG_arg_fail(1)) SWIG_fail;
23166 }
23167 }
23168 if (obj1) {
23169 {
23170 arg2 = static_cast<int >(SWIG_As_int(obj1));
23171 if (SWIG_arg_fail(2)) SWIG_fail;
23172 }
23173 }
23174 {
23175 PyThreadState* __tstate = wxPyBeginAllowThreads();
23176 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
23177
23178 wxPyEndAllowThreads(__tstate);
23179 if (PyErr_Occurred()) SWIG_fail;
23180 }
23181 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
23182 return resultobj;
23183 fail:
23184 return NULL;
23185 }
23186
23187
23188 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23189 PyObject *resultobj = NULL;
23190 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23191 PyObject * obj0 = 0 ;
23192 char *kwnames[] = {
23193 (char *) "self", NULL
23194 };
23195
23196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
23197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23198 if (SWIG_arg_fail(1)) SWIG_fail;
23199 {
23200 PyThreadState* __tstate = wxPyBeginAllowThreads();
23201 delete arg1;
23202
23203 wxPyEndAllowThreads(__tstate);
23204 if (PyErr_Occurred()) SWIG_fail;
23205 }
23206 Py_INCREF(Py_None); resultobj = Py_None;
23207 return resultobj;
23208 fail:
23209 return NULL;
23210 }
23211
23212
23213 static PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23214 PyObject *resultobj = NULL;
23215 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23216 PyObject *arg2 = (PyObject *) 0 ;
23217 PyObject * obj0 = 0 ;
23218 PyObject * obj1 = 0 ;
23219 char *kwnames[] = {
23220 (char *) "self",(char *) "self", NULL
23221 };
23222
23223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
23224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23225 if (SWIG_arg_fail(1)) SWIG_fail;
23226 arg2 = obj1;
23227 {
23228 PyThreadState* __tstate = wxPyBeginAllowThreads();
23229 (arg1)->SetSelf(arg2);
23230
23231 wxPyEndAllowThreads(__tstate);
23232 if (PyErr_Occurred()) SWIG_fail;
23233 }
23234 Py_INCREF(Py_None); resultobj = Py_None;
23235 return resultobj;
23236 fail:
23237 return NULL;
23238 }
23239
23240
23241 static PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
23242 PyObject *resultobj = NULL;
23243 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
23244 PyObject *result;
23245 PyObject * obj0 = 0 ;
23246 char *kwnames[] = {
23247 (char *) "self", NULL
23248 };
23249
23250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent__GetSelf",kwnames,&obj0)) goto fail;
23251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23252 if (SWIG_arg_fail(1)) SWIG_fail;
23253 {
23254 PyThreadState* __tstate = wxPyBeginAllowThreads();
23255 result = (PyObject *)(arg1)->GetSelf();
23256
23257 wxPyEndAllowThreads(__tstate);
23258 if (PyErr_Occurred()) SWIG_fail;
23259 }
23260 resultobj = result;
23261 return resultobj;
23262 fail:
23263 return NULL;
23264 }
23265
23266
23267 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
23268 PyObject *obj;
23269 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23270 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
23271 Py_INCREF(obj);
23272 return Py_BuildValue((char *)"");
23273 }
23274 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23275 PyObject *resultobj = NULL;
23276 wxWindow *arg1 = (wxWindow *) 0 ;
23277 wxDateTime *arg2 = 0 ;
23278 wxEventType arg3 ;
23279 wxDateEvent *result;
23280 PyObject * obj0 = 0 ;
23281 PyObject * obj1 = 0 ;
23282 PyObject * obj2 = 0 ;
23283 char *kwnames[] = {
23284 (char *) "win",(char *) "dt",(char *) "type", NULL
23285 };
23286
23287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
23288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23289 if (SWIG_arg_fail(1)) SWIG_fail;
23290 {
23291 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23292 if (SWIG_arg_fail(2)) SWIG_fail;
23293 if (arg2 == NULL) {
23294 SWIG_null_ref("wxDateTime");
23295 }
23296 if (SWIG_arg_fail(2)) SWIG_fail;
23297 }
23298 {
23299 arg3 = static_cast<wxEventType >(SWIG_As_int(obj2));
23300 if (SWIG_arg_fail(3)) SWIG_fail;
23301 }
23302 {
23303 PyThreadState* __tstate = wxPyBeginAllowThreads();
23304 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
23305
23306 wxPyEndAllowThreads(__tstate);
23307 if (PyErr_Occurred()) SWIG_fail;
23308 }
23309 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
23310 return resultobj;
23311 fail:
23312 return NULL;
23313 }
23314
23315
23316 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23317 PyObject *resultobj = NULL;
23318 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23319 wxDateTime *result;
23320 PyObject * obj0 = 0 ;
23321 char *kwnames[] = {
23322 (char *) "self", NULL
23323 };
23324
23325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
23326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23327 if (SWIG_arg_fail(1)) SWIG_fail;
23328 {
23329 PyThreadState* __tstate = wxPyBeginAllowThreads();
23330 {
23331 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
23332 result = (wxDateTime *) &_result_ref;
23333 }
23334
23335 wxPyEndAllowThreads(__tstate);
23336 if (PyErr_Occurred()) SWIG_fail;
23337 }
23338 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23339 return resultobj;
23340 fail:
23341 return NULL;
23342 }
23343
23344
23345 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23346 PyObject *resultobj = NULL;
23347 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23348 wxDateTime *arg2 = 0 ;
23349 PyObject * obj0 = 0 ;
23350 PyObject * obj1 = 0 ;
23351 char *kwnames[] = {
23352 (char *) "self",(char *) "date", NULL
23353 };
23354
23355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
23356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23357 if (SWIG_arg_fail(1)) SWIG_fail;
23358 {
23359 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23360 if (SWIG_arg_fail(2)) SWIG_fail;
23361 if (arg2 == NULL) {
23362 SWIG_null_ref("wxDateTime");
23363 }
23364 if (SWIG_arg_fail(2)) SWIG_fail;
23365 }
23366 {
23367 PyThreadState* __tstate = wxPyBeginAllowThreads();
23368 (arg1)->SetDate((wxDateTime const &)*arg2);
23369
23370 wxPyEndAllowThreads(__tstate);
23371 if (PyErr_Occurred()) SWIG_fail;
23372 }
23373 Py_INCREF(Py_None); resultobj = Py_None;
23374 return resultobj;
23375 fail:
23376 return NULL;
23377 }
23378
23379
23380 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
23381 PyObject *obj;
23382 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23383 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
23384 Py_INCREF(obj);
23385 return Py_BuildValue((char *)"");
23386 }
23387 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23388 PyObject *resultobj = NULL;
23389 wxPyApp *result;
23390 char *kwnames[] = {
23391 NULL
23392 };
23393
23394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
23395 {
23396 PyThreadState* __tstate = wxPyBeginAllowThreads();
23397 result = (wxPyApp *)new_wxPyApp();
23398
23399 wxPyEndAllowThreads(__tstate);
23400 if (PyErr_Occurred()) SWIG_fail;
23401 }
23402 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
23403 return resultobj;
23404 fail:
23405 return NULL;
23406 }
23407
23408
23409 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23410 PyObject *resultobj = NULL;
23411 wxPyApp *arg1 = (wxPyApp *) 0 ;
23412 PyObject * obj0 = 0 ;
23413 char *kwnames[] = {
23414 (char *) "self", NULL
23415 };
23416
23417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
23418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23419 if (SWIG_arg_fail(1)) SWIG_fail;
23420 {
23421 PyThreadState* __tstate = wxPyBeginAllowThreads();
23422 delete arg1;
23423
23424 wxPyEndAllowThreads(__tstate);
23425 if (PyErr_Occurred()) SWIG_fail;
23426 }
23427 Py_INCREF(Py_None); resultobj = Py_None;
23428 return resultobj;
23429 fail:
23430 return NULL;
23431 }
23432
23433
23434 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
23435 PyObject *resultobj = NULL;
23436 wxPyApp *arg1 = (wxPyApp *) 0 ;
23437 PyObject *arg2 = (PyObject *) 0 ;
23438 PyObject *arg3 = (PyObject *) 0 ;
23439 bool arg4 ;
23440 PyObject * obj0 = 0 ;
23441 PyObject * obj1 = 0 ;
23442 PyObject * obj2 = 0 ;
23443 PyObject * obj3 = 0 ;
23444 char *kwnames[] = {
23445 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
23446 };
23447
23448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23450 if (SWIG_arg_fail(1)) SWIG_fail;
23451 arg2 = obj1;
23452 arg3 = obj2;
23453 {
23454 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
23455 if (SWIG_arg_fail(4)) SWIG_fail;
23456 }
23457 {
23458 PyThreadState* __tstate = wxPyBeginAllowThreads();
23459 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
23460
23461 wxPyEndAllowThreads(__tstate);
23462 if (PyErr_Occurred()) SWIG_fail;
23463 }
23464 Py_INCREF(Py_None); resultobj = Py_None;
23465 return resultobj;
23466 fail:
23467 return NULL;
23468 }
23469
23470
23471 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23472 PyObject *resultobj = NULL;
23473 wxPyApp *arg1 = (wxPyApp *) 0 ;
23474 wxString result;
23475 PyObject * obj0 = 0 ;
23476 char *kwnames[] = {
23477 (char *) "self", NULL
23478 };
23479
23480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
23481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23482 if (SWIG_arg_fail(1)) SWIG_fail;
23483 {
23484 PyThreadState* __tstate = wxPyBeginAllowThreads();
23485 result = ((wxPyApp const *)arg1)->GetAppName();
23486
23487 wxPyEndAllowThreads(__tstate);
23488 if (PyErr_Occurred()) SWIG_fail;
23489 }
23490 {
23491 #if wxUSE_UNICODE
23492 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23493 #else
23494 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23495 #endif
23496 }
23497 return resultobj;
23498 fail:
23499 return NULL;
23500 }
23501
23502
23503 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23504 PyObject *resultobj = NULL;
23505 wxPyApp *arg1 = (wxPyApp *) 0 ;
23506 wxString *arg2 = 0 ;
23507 bool temp2 = false ;
23508 PyObject * obj0 = 0 ;
23509 PyObject * obj1 = 0 ;
23510 char *kwnames[] = {
23511 (char *) "self",(char *) "name", NULL
23512 };
23513
23514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
23515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23516 if (SWIG_arg_fail(1)) SWIG_fail;
23517 {
23518 arg2 = wxString_in_helper(obj1);
23519 if (arg2 == NULL) SWIG_fail;
23520 temp2 = true;
23521 }
23522 {
23523 PyThreadState* __tstate = wxPyBeginAllowThreads();
23524 (arg1)->SetAppName((wxString const &)*arg2);
23525
23526 wxPyEndAllowThreads(__tstate);
23527 if (PyErr_Occurred()) SWIG_fail;
23528 }
23529 Py_INCREF(Py_None); resultobj = Py_None;
23530 {
23531 if (temp2)
23532 delete arg2;
23533 }
23534 return resultobj;
23535 fail:
23536 {
23537 if (temp2)
23538 delete arg2;
23539 }
23540 return NULL;
23541 }
23542
23543
23544 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23545 PyObject *resultobj = NULL;
23546 wxPyApp *arg1 = (wxPyApp *) 0 ;
23547 wxString result;
23548 PyObject * obj0 = 0 ;
23549 char *kwnames[] = {
23550 (char *) "self", NULL
23551 };
23552
23553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
23554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23555 if (SWIG_arg_fail(1)) SWIG_fail;
23556 {
23557 PyThreadState* __tstate = wxPyBeginAllowThreads();
23558 result = ((wxPyApp const *)arg1)->GetClassName();
23559
23560 wxPyEndAllowThreads(__tstate);
23561 if (PyErr_Occurred()) SWIG_fail;
23562 }
23563 {
23564 #if wxUSE_UNICODE
23565 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23566 #else
23567 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23568 #endif
23569 }
23570 return resultobj;
23571 fail:
23572 return NULL;
23573 }
23574
23575
23576 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23577 PyObject *resultobj = NULL;
23578 wxPyApp *arg1 = (wxPyApp *) 0 ;
23579 wxString *arg2 = 0 ;
23580 bool temp2 = false ;
23581 PyObject * obj0 = 0 ;
23582 PyObject * obj1 = 0 ;
23583 char *kwnames[] = {
23584 (char *) "self",(char *) "name", NULL
23585 };
23586
23587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
23588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23589 if (SWIG_arg_fail(1)) SWIG_fail;
23590 {
23591 arg2 = wxString_in_helper(obj1);
23592 if (arg2 == NULL) SWIG_fail;
23593 temp2 = true;
23594 }
23595 {
23596 PyThreadState* __tstate = wxPyBeginAllowThreads();
23597 (arg1)->SetClassName((wxString const &)*arg2);
23598
23599 wxPyEndAllowThreads(__tstate);
23600 if (PyErr_Occurred()) SWIG_fail;
23601 }
23602 Py_INCREF(Py_None); resultobj = Py_None;
23603 {
23604 if (temp2)
23605 delete arg2;
23606 }
23607 return resultobj;
23608 fail:
23609 {
23610 if (temp2)
23611 delete arg2;
23612 }
23613 return NULL;
23614 }
23615
23616
23617 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23618 PyObject *resultobj = NULL;
23619 wxPyApp *arg1 = (wxPyApp *) 0 ;
23620 wxString *result;
23621 PyObject * obj0 = 0 ;
23622 char *kwnames[] = {
23623 (char *) "self", NULL
23624 };
23625
23626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
23627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23628 if (SWIG_arg_fail(1)) SWIG_fail;
23629 {
23630 PyThreadState* __tstate = wxPyBeginAllowThreads();
23631 {
23632 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
23633 result = (wxString *) &_result_ref;
23634 }
23635
23636 wxPyEndAllowThreads(__tstate);
23637 if (PyErr_Occurred()) SWIG_fail;
23638 }
23639 {
23640 #if wxUSE_UNICODE
23641 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23642 #else
23643 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23644 #endif
23645 }
23646 return resultobj;
23647 fail:
23648 return NULL;
23649 }
23650
23651
23652 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23653 PyObject *resultobj = NULL;
23654 wxPyApp *arg1 = (wxPyApp *) 0 ;
23655 wxString *arg2 = 0 ;
23656 bool temp2 = false ;
23657 PyObject * obj0 = 0 ;
23658 PyObject * obj1 = 0 ;
23659 char *kwnames[] = {
23660 (char *) "self",(char *) "name", NULL
23661 };
23662
23663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
23664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23665 if (SWIG_arg_fail(1)) SWIG_fail;
23666 {
23667 arg2 = wxString_in_helper(obj1);
23668 if (arg2 == NULL) SWIG_fail;
23669 temp2 = true;
23670 }
23671 {
23672 PyThreadState* __tstate = wxPyBeginAllowThreads();
23673 (arg1)->SetVendorName((wxString const &)*arg2);
23674
23675 wxPyEndAllowThreads(__tstate);
23676 if (PyErr_Occurred()) SWIG_fail;
23677 }
23678 Py_INCREF(Py_None); resultobj = Py_None;
23679 {
23680 if (temp2)
23681 delete arg2;
23682 }
23683 return resultobj;
23684 fail:
23685 {
23686 if (temp2)
23687 delete arg2;
23688 }
23689 return NULL;
23690 }
23691
23692
23693 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
23694 PyObject *resultobj = NULL;
23695 wxPyApp *arg1 = (wxPyApp *) 0 ;
23696 wxAppTraits *result;
23697 PyObject * obj0 = 0 ;
23698 char *kwnames[] = {
23699 (char *) "self", NULL
23700 };
23701
23702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
23703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23704 if (SWIG_arg_fail(1)) SWIG_fail;
23705 {
23706 PyThreadState* __tstate = wxPyBeginAllowThreads();
23707 result = (wxAppTraits *)(arg1)->GetTraits();
23708
23709 wxPyEndAllowThreads(__tstate);
23710 if (PyErr_Occurred()) SWIG_fail;
23711 }
23712 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
23713 return resultobj;
23714 fail:
23715 return NULL;
23716 }
23717
23718
23719 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23720 PyObject *resultobj = NULL;
23721 wxPyApp *arg1 = (wxPyApp *) 0 ;
23722 PyObject * obj0 = 0 ;
23723 char *kwnames[] = {
23724 (char *) "self", NULL
23725 };
23726
23727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
23728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23729 if (SWIG_arg_fail(1)) SWIG_fail;
23730 {
23731 PyThreadState* __tstate = wxPyBeginAllowThreads();
23732 (arg1)->ProcessPendingEvents();
23733
23734 wxPyEndAllowThreads(__tstate);
23735 if (PyErr_Occurred()) SWIG_fail;
23736 }
23737 Py_INCREF(Py_None); resultobj = Py_None;
23738 return resultobj;
23739 fail:
23740 return NULL;
23741 }
23742
23743
23744 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23745 PyObject *resultobj = NULL;
23746 wxPyApp *arg1 = (wxPyApp *) 0 ;
23747 bool arg2 = (bool) false ;
23748 bool result;
23749 PyObject * obj0 = 0 ;
23750 PyObject * obj1 = 0 ;
23751 char *kwnames[] = {
23752 (char *) "self",(char *) "onlyIfNeeded", NULL
23753 };
23754
23755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
23756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23757 if (SWIG_arg_fail(1)) SWIG_fail;
23758 if (obj1) {
23759 {
23760 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
23761 if (SWIG_arg_fail(2)) SWIG_fail;
23762 }
23763 }
23764 {
23765 PyThreadState* __tstate = wxPyBeginAllowThreads();
23766 result = (bool)(arg1)->Yield(arg2);
23767
23768 wxPyEndAllowThreads(__tstate);
23769 if (PyErr_Occurred()) SWIG_fail;
23770 }
23771 {
23772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23773 }
23774 return resultobj;
23775 fail:
23776 return NULL;
23777 }
23778
23779
23780 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23781 PyObject *resultobj = NULL;
23782 wxPyApp *arg1 = (wxPyApp *) 0 ;
23783 PyObject * obj0 = 0 ;
23784 char *kwnames[] = {
23785 (char *) "self", NULL
23786 };
23787
23788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23790 if (SWIG_arg_fail(1)) SWIG_fail;
23791 {
23792 PyThreadState* __tstate = wxPyBeginAllowThreads();
23793 (arg1)->WakeUpIdle();
23794
23795 wxPyEndAllowThreads(__tstate);
23796 if (PyErr_Occurred()) SWIG_fail;
23797 }
23798 Py_INCREF(Py_None); resultobj = Py_None;
23799 return resultobj;
23800 fail:
23801 return NULL;
23802 }
23803
23804
23805 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23806 PyObject *resultobj = NULL;
23807 bool result;
23808 char *kwnames[] = {
23809 NULL
23810 };
23811
23812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23813 {
23814 PyThreadState* __tstate = wxPyBeginAllowThreads();
23815 result = (bool)wxPyApp::IsMainLoopRunning();
23816
23817 wxPyEndAllowThreads(__tstate);
23818 if (PyErr_Occurred()) SWIG_fail;
23819 }
23820 {
23821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23822 }
23823 return resultobj;
23824 fail:
23825 return NULL;
23826 }
23827
23828
23829 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23830 PyObject *resultobj = NULL;
23831 wxPyApp *arg1 = (wxPyApp *) 0 ;
23832 int result;
23833 PyObject * obj0 = 0 ;
23834 char *kwnames[] = {
23835 (char *) "self", NULL
23836 };
23837
23838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23839 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23840 if (SWIG_arg_fail(1)) SWIG_fail;
23841 {
23842 PyThreadState* __tstate = wxPyBeginAllowThreads();
23843 result = (int)(arg1)->MainLoop();
23844
23845 wxPyEndAllowThreads(__tstate);
23846 if (PyErr_Occurred()) SWIG_fail;
23847 }
23848 {
23849 resultobj = SWIG_From_int(static_cast<int >(result));
23850 }
23851 return resultobj;
23852 fail:
23853 return NULL;
23854 }
23855
23856
23857 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23858 PyObject *resultobj = NULL;
23859 wxPyApp *arg1 = (wxPyApp *) 0 ;
23860 PyObject * obj0 = 0 ;
23861 char *kwnames[] = {
23862 (char *) "self", NULL
23863 };
23864
23865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23867 if (SWIG_arg_fail(1)) SWIG_fail;
23868 {
23869 PyThreadState* __tstate = wxPyBeginAllowThreads();
23870 (arg1)->Exit();
23871
23872 wxPyEndAllowThreads(__tstate);
23873 if (PyErr_Occurred()) SWIG_fail;
23874 }
23875 Py_INCREF(Py_None); resultobj = Py_None;
23876 return resultobj;
23877 fail:
23878 return NULL;
23879 }
23880
23881
23882 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23883 PyObject *resultobj = NULL;
23884 wxPyApp *arg1 = (wxPyApp *) 0 ;
23885 PyObject * obj0 = 0 ;
23886 char *kwnames[] = {
23887 (char *) "self", NULL
23888 };
23889
23890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23892 if (SWIG_arg_fail(1)) SWIG_fail;
23893 {
23894 PyThreadState* __tstate = wxPyBeginAllowThreads();
23895 (arg1)->ExitMainLoop();
23896
23897 wxPyEndAllowThreads(__tstate);
23898 if (PyErr_Occurred()) SWIG_fail;
23899 }
23900 Py_INCREF(Py_None); resultobj = Py_None;
23901 return resultobj;
23902 fail:
23903 return NULL;
23904 }
23905
23906
23907 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23908 PyObject *resultobj = NULL;
23909 wxPyApp *arg1 = (wxPyApp *) 0 ;
23910 bool result;
23911 PyObject * obj0 = 0 ;
23912 char *kwnames[] = {
23913 (char *) "self", NULL
23914 };
23915
23916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23918 if (SWIG_arg_fail(1)) SWIG_fail;
23919 {
23920 PyThreadState* __tstate = wxPyBeginAllowThreads();
23921 result = (bool)(arg1)->Pending();
23922
23923 wxPyEndAllowThreads(__tstate);
23924 if (PyErr_Occurred()) SWIG_fail;
23925 }
23926 {
23927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23928 }
23929 return resultobj;
23930 fail:
23931 return NULL;
23932 }
23933
23934
23935 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23936 PyObject *resultobj = NULL;
23937 wxPyApp *arg1 = (wxPyApp *) 0 ;
23938 bool result;
23939 PyObject * obj0 = 0 ;
23940 char *kwnames[] = {
23941 (char *) "self", NULL
23942 };
23943
23944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23945 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23946 if (SWIG_arg_fail(1)) SWIG_fail;
23947 {
23948 PyThreadState* __tstate = wxPyBeginAllowThreads();
23949 result = (bool)(arg1)->Dispatch();
23950
23951 wxPyEndAllowThreads(__tstate);
23952 if (PyErr_Occurred()) SWIG_fail;
23953 }
23954 {
23955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23956 }
23957 return resultobj;
23958 fail:
23959 return NULL;
23960 }
23961
23962
23963 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23964 PyObject *resultobj = NULL;
23965 wxPyApp *arg1 = (wxPyApp *) 0 ;
23966 bool result;
23967 PyObject * obj0 = 0 ;
23968 char *kwnames[] = {
23969 (char *) "self", NULL
23970 };
23971
23972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23974 if (SWIG_arg_fail(1)) SWIG_fail;
23975 {
23976 PyThreadState* __tstate = wxPyBeginAllowThreads();
23977 result = (bool)(arg1)->ProcessIdle();
23978
23979 wxPyEndAllowThreads(__tstate);
23980 if (PyErr_Occurred()) SWIG_fail;
23981 }
23982 {
23983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23984 }
23985 return resultobj;
23986 fail:
23987 return NULL;
23988 }
23989
23990
23991 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23992 PyObject *resultobj = NULL;
23993 wxPyApp *arg1 = (wxPyApp *) 0 ;
23994 wxWindow *arg2 = (wxWindow *) 0 ;
23995 wxIdleEvent *arg3 = 0 ;
23996 bool result;
23997 PyObject * obj0 = 0 ;
23998 PyObject * obj1 = 0 ;
23999 PyObject * obj2 = 0 ;
24000 char *kwnames[] = {
24001 (char *) "self",(char *) "win",(char *) "event", NULL
24002 };
24003
24004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
24005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24006 if (SWIG_arg_fail(1)) SWIG_fail;
24007 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24008 if (SWIG_arg_fail(2)) SWIG_fail;
24009 {
24010 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
24011 if (SWIG_arg_fail(3)) SWIG_fail;
24012 if (arg3 == NULL) {
24013 SWIG_null_ref("wxIdleEvent");
24014 }
24015 if (SWIG_arg_fail(3)) SWIG_fail;
24016 }
24017 {
24018 PyThreadState* __tstate = wxPyBeginAllowThreads();
24019 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
24020
24021 wxPyEndAllowThreads(__tstate);
24022 if (PyErr_Occurred()) SWIG_fail;
24023 }
24024 {
24025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24026 }
24027 return resultobj;
24028 fail:
24029 return NULL;
24030 }
24031
24032
24033 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
24034 PyObject *resultobj = NULL;
24035 wxPyApp *arg1 = (wxPyApp *) 0 ;
24036 bool result;
24037 PyObject * obj0 = 0 ;
24038 char *kwnames[] = {
24039 (char *) "self", NULL
24040 };
24041
24042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
24043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24044 if (SWIG_arg_fail(1)) SWIG_fail;
24045 {
24046 PyThreadState* __tstate = wxPyBeginAllowThreads();
24047 result = (bool)((wxPyApp const *)arg1)->IsActive();
24048
24049 wxPyEndAllowThreads(__tstate);
24050 if (PyErr_Occurred()) SWIG_fail;
24051 }
24052 {
24053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24054 }
24055 return resultobj;
24056 fail:
24057 return NULL;
24058 }
24059
24060
24061 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24062 PyObject *resultobj = NULL;
24063 wxPyApp *arg1 = (wxPyApp *) 0 ;
24064 wxWindow *arg2 = (wxWindow *) 0 ;
24065 PyObject * obj0 = 0 ;
24066 PyObject * obj1 = 0 ;
24067 char *kwnames[] = {
24068 (char *) "self",(char *) "win", NULL
24069 };
24070
24071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
24072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24073 if (SWIG_arg_fail(1)) SWIG_fail;
24074 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24075 if (SWIG_arg_fail(2)) SWIG_fail;
24076 {
24077 PyThreadState* __tstate = wxPyBeginAllowThreads();
24078 (arg1)->SetTopWindow(arg2);
24079
24080 wxPyEndAllowThreads(__tstate);
24081 if (PyErr_Occurred()) SWIG_fail;
24082 }
24083 Py_INCREF(Py_None); resultobj = Py_None;
24084 return resultobj;
24085 fail:
24086 return NULL;
24087 }
24088
24089
24090 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24091 PyObject *resultobj = NULL;
24092 wxPyApp *arg1 = (wxPyApp *) 0 ;
24093 wxWindow *result;
24094 PyObject * obj0 = 0 ;
24095 char *kwnames[] = {
24096 (char *) "self", NULL
24097 };
24098
24099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
24100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24101 if (SWIG_arg_fail(1)) SWIG_fail;
24102 {
24103 PyThreadState* __tstate = wxPyBeginAllowThreads();
24104 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
24105
24106 wxPyEndAllowThreads(__tstate);
24107 if (PyErr_Occurred()) SWIG_fail;
24108 }
24109 {
24110 resultobj = wxPyMake_wxObject(result, (bool)0);
24111 }
24112 return resultobj;
24113 fail:
24114 return NULL;
24115 }
24116
24117
24118 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
24119 PyObject *resultobj = NULL;
24120 wxPyApp *arg1 = (wxPyApp *) 0 ;
24121 bool arg2 ;
24122 PyObject * obj0 = 0 ;
24123 PyObject * obj1 = 0 ;
24124 char *kwnames[] = {
24125 (char *) "self",(char *) "flag", NULL
24126 };
24127
24128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
24129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24130 if (SWIG_arg_fail(1)) SWIG_fail;
24131 {
24132 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24133 if (SWIG_arg_fail(2)) SWIG_fail;
24134 }
24135 {
24136 PyThreadState* __tstate = wxPyBeginAllowThreads();
24137 (arg1)->SetExitOnFrameDelete(arg2);
24138
24139 wxPyEndAllowThreads(__tstate);
24140 if (PyErr_Occurred()) SWIG_fail;
24141 }
24142 Py_INCREF(Py_None); resultobj = Py_None;
24143 return resultobj;
24144 fail:
24145 return NULL;
24146 }
24147
24148
24149 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
24150 PyObject *resultobj = NULL;
24151 wxPyApp *arg1 = (wxPyApp *) 0 ;
24152 bool result;
24153 PyObject * obj0 = 0 ;
24154 char *kwnames[] = {
24155 (char *) "self", NULL
24156 };
24157
24158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
24159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24160 if (SWIG_arg_fail(1)) SWIG_fail;
24161 {
24162 PyThreadState* __tstate = wxPyBeginAllowThreads();
24163 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
24164
24165 wxPyEndAllowThreads(__tstate);
24166 if (PyErr_Occurred()) SWIG_fail;
24167 }
24168 {
24169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24170 }
24171 return resultobj;
24172 fail:
24173 return NULL;
24174 }
24175
24176
24177 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24178 PyObject *resultobj = NULL;
24179 wxPyApp *arg1 = (wxPyApp *) 0 ;
24180 bool arg2 ;
24181 PyObject * obj0 = 0 ;
24182 PyObject * obj1 = 0 ;
24183 char *kwnames[] = {
24184 (char *) "self",(char *) "flag", NULL
24185 };
24186
24187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
24188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24189 if (SWIG_arg_fail(1)) SWIG_fail;
24190 {
24191 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24192 if (SWIG_arg_fail(2)) SWIG_fail;
24193 }
24194 {
24195 PyThreadState* __tstate = wxPyBeginAllowThreads();
24196 (arg1)->SetUseBestVisual(arg2);
24197
24198 wxPyEndAllowThreads(__tstate);
24199 if (PyErr_Occurred()) SWIG_fail;
24200 }
24201 Py_INCREF(Py_None); resultobj = Py_None;
24202 return resultobj;
24203 fail:
24204 return NULL;
24205 }
24206
24207
24208 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
24209 PyObject *resultobj = NULL;
24210 wxPyApp *arg1 = (wxPyApp *) 0 ;
24211 bool result;
24212 PyObject * obj0 = 0 ;
24213 char *kwnames[] = {
24214 (char *) "self", NULL
24215 };
24216
24217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
24218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24219 if (SWIG_arg_fail(1)) SWIG_fail;
24220 {
24221 PyThreadState* __tstate = wxPyBeginAllowThreads();
24222 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
24223
24224 wxPyEndAllowThreads(__tstate);
24225 if (PyErr_Occurred()) SWIG_fail;
24226 }
24227 {
24228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24229 }
24230 return resultobj;
24231 fail:
24232 return NULL;
24233 }
24234
24235
24236 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24237 PyObject *resultobj = NULL;
24238 wxPyApp *arg1 = (wxPyApp *) 0 ;
24239 int arg2 ;
24240 PyObject * obj0 = 0 ;
24241 PyObject * obj1 = 0 ;
24242 char *kwnames[] = {
24243 (char *) "self",(char *) "mode", NULL
24244 };
24245
24246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
24247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24248 if (SWIG_arg_fail(1)) SWIG_fail;
24249 {
24250 arg2 = static_cast<int >(SWIG_As_int(obj1));
24251 if (SWIG_arg_fail(2)) SWIG_fail;
24252 }
24253 {
24254 PyThreadState* __tstate = wxPyBeginAllowThreads();
24255 (arg1)->SetPrintMode(arg2);
24256
24257 wxPyEndAllowThreads(__tstate);
24258 if (PyErr_Occurred()) SWIG_fail;
24259 }
24260 Py_INCREF(Py_None); resultobj = Py_None;
24261 return resultobj;
24262 fail:
24263 return NULL;
24264 }
24265
24266
24267 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24268 PyObject *resultobj = NULL;
24269 wxPyApp *arg1 = (wxPyApp *) 0 ;
24270 int result;
24271 PyObject * obj0 = 0 ;
24272 char *kwnames[] = {
24273 (char *) "self", NULL
24274 };
24275
24276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
24277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24278 if (SWIG_arg_fail(1)) SWIG_fail;
24279 {
24280 PyThreadState* __tstate = wxPyBeginAllowThreads();
24281 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
24282
24283 wxPyEndAllowThreads(__tstate);
24284 if (PyErr_Occurred()) SWIG_fail;
24285 }
24286 {
24287 resultobj = SWIG_From_int(static_cast<int >(result));
24288 }
24289 return resultobj;
24290 fail:
24291 return NULL;
24292 }
24293
24294
24295 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24296 PyObject *resultobj = NULL;
24297 wxPyApp *arg1 = (wxPyApp *) 0 ;
24298 int arg2 ;
24299 PyObject * obj0 = 0 ;
24300 PyObject * obj1 = 0 ;
24301 char *kwnames[] = {
24302 (char *) "self",(char *) "mode", NULL
24303 };
24304
24305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
24306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24307 if (SWIG_arg_fail(1)) SWIG_fail;
24308 {
24309 arg2 = static_cast<int >(SWIG_As_int(obj1));
24310 if (SWIG_arg_fail(2)) SWIG_fail;
24311 }
24312 {
24313 PyThreadState* __tstate = wxPyBeginAllowThreads();
24314 (arg1)->SetAssertMode(arg2);
24315
24316 wxPyEndAllowThreads(__tstate);
24317 if (PyErr_Occurred()) SWIG_fail;
24318 }
24319 Py_INCREF(Py_None); resultobj = Py_None;
24320 return resultobj;
24321 fail:
24322 return NULL;
24323 }
24324
24325
24326 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24327 PyObject *resultobj = NULL;
24328 wxPyApp *arg1 = (wxPyApp *) 0 ;
24329 int result;
24330 PyObject * obj0 = 0 ;
24331 char *kwnames[] = {
24332 (char *) "self", NULL
24333 };
24334
24335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
24336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24337 if (SWIG_arg_fail(1)) SWIG_fail;
24338 {
24339 PyThreadState* __tstate = wxPyBeginAllowThreads();
24340 result = (int)(arg1)->GetAssertMode();
24341
24342 wxPyEndAllowThreads(__tstate);
24343 if (PyErr_Occurred()) SWIG_fail;
24344 }
24345 {
24346 resultobj = SWIG_From_int(static_cast<int >(result));
24347 }
24348 return resultobj;
24349 fail:
24350 return NULL;
24351 }
24352
24353
24354 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24355 PyObject *resultobj = NULL;
24356 bool result;
24357 char *kwnames[] = {
24358 NULL
24359 };
24360
24361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
24362 {
24363 PyThreadState* __tstate = wxPyBeginAllowThreads();
24364 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
24365
24366 wxPyEndAllowThreads(__tstate);
24367 if (PyErr_Occurred()) SWIG_fail;
24368 }
24369 {
24370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24371 }
24372 return resultobj;
24373 fail:
24374 return NULL;
24375 }
24376
24377
24378 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24379 PyObject *resultobj = NULL;
24380 long result;
24381 char *kwnames[] = {
24382 NULL
24383 };
24384
24385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
24386 {
24387 PyThreadState* __tstate = wxPyBeginAllowThreads();
24388 result = (long)wxPyApp::GetMacAboutMenuItemId();
24389
24390 wxPyEndAllowThreads(__tstate);
24391 if (PyErr_Occurred()) SWIG_fail;
24392 }
24393 {
24394 resultobj = SWIG_From_long(static_cast<long >(result));
24395 }
24396 return resultobj;
24397 fail:
24398 return NULL;
24399 }
24400
24401
24402 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24403 PyObject *resultobj = NULL;
24404 long result;
24405 char *kwnames[] = {
24406 NULL
24407 };
24408
24409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
24410 {
24411 PyThreadState* __tstate = wxPyBeginAllowThreads();
24412 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
24413
24414 wxPyEndAllowThreads(__tstate);
24415 if (PyErr_Occurred()) SWIG_fail;
24416 }
24417 {
24418 resultobj = SWIG_From_long(static_cast<long >(result));
24419 }
24420 return resultobj;
24421 fail:
24422 return NULL;
24423 }
24424
24425
24426 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24427 PyObject *resultobj = NULL;
24428 long result;
24429 char *kwnames[] = {
24430 NULL
24431 };
24432
24433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
24434 {
24435 PyThreadState* __tstate = wxPyBeginAllowThreads();
24436 result = (long)wxPyApp::GetMacExitMenuItemId();
24437
24438 wxPyEndAllowThreads(__tstate);
24439 if (PyErr_Occurred()) SWIG_fail;
24440 }
24441 {
24442 resultobj = SWIG_From_long(static_cast<long >(result));
24443 }
24444 return resultobj;
24445 fail:
24446 return NULL;
24447 }
24448
24449
24450 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24451 PyObject *resultobj = NULL;
24452 wxString result;
24453 char *kwnames[] = {
24454 NULL
24455 };
24456
24457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
24458 {
24459 PyThreadState* __tstate = wxPyBeginAllowThreads();
24460 result = wxPyApp::GetMacHelpMenuTitleName();
24461
24462 wxPyEndAllowThreads(__tstate);
24463 if (PyErr_Occurred()) SWIG_fail;
24464 }
24465 {
24466 #if wxUSE_UNICODE
24467 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24468 #else
24469 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24470 #endif
24471 }
24472 return resultobj;
24473 fail:
24474 return NULL;
24475 }
24476
24477
24478 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24479 PyObject *resultobj = NULL;
24480 bool arg1 ;
24481 PyObject * obj0 = 0 ;
24482 char *kwnames[] = {
24483 (char *) "val", NULL
24484 };
24485
24486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
24487 {
24488 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
24489 if (SWIG_arg_fail(1)) SWIG_fail;
24490 }
24491 {
24492 PyThreadState* __tstate = wxPyBeginAllowThreads();
24493 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
24494
24495 wxPyEndAllowThreads(__tstate);
24496 if (PyErr_Occurred()) SWIG_fail;
24497 }
24498 Py_INCREF(Py_None); resultobj = Py_None;
24499 return resultobj;
24500 fail:
24501 return NULL;
24502 }
24503
24504
24505 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24506 PyObject *resultobj = NULL;
24507 long arg1 ;
24508 PyObject * obj0 = 0 ;
24509 char *kwnames[] = {
24510 (char *) "val", NULL
24511 };
24512
24513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
24514 {
24515 arg1 = static_cast<long >(SWIG_As_long(obj0));
24516 if (SWIG_arg_fail(1)) SWIG_fail;
24517 }
24518 {
24519 PyThreadState* __tstate = wxPyBeginAllowThreads();
24520 wxPyApp::SetMacAboutMenuItemId(arg1);
24521
24522 wxPyEndAllowThreads(__tstate);
24523 if (PyErr_Occurred()) SWIG_fail;
24524 }
24525 Py_INCREF(Py_None); resultobj = Py_None;
24526 return resultobj;
24527 fail:
24528 return NULL;
24529 }
24530
24531
24532 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24533 PyObject *resultobj = NULL;
24534 long arg1 ;
24535 PyObject * obj0 = 0 ;
24536 char *kwnames[] = {
24537 (char *) "val", NULL
24538 };
24539
24540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
24541 {
24542 arg1 = static_cast<long >(SWIG_As_long(obj0));
24543 if (SWIG_arg_fail(1)) SWIG_fail;
24544 }
24545 {
24546 PyThreadState* __tstate = wxPyBeginAllowThreads();
24547 wxPyApp::SetMacPreferencesMenuItemId(arg1);
24548
24549 wxPyEndAllowThreads(__tstate);
24550 if (PyErr_Occurred()) SWIG_fail;
24551 }
24552 Py_INCREF(Py_None); resultobj = Py_None;
24553 return resultobj;
24554 fail:
24555 return NULL;
24556 }
24557
24558
24559 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24560 PyObject *resultobj = NULL;
24561 long arg1 ;
24562 PyObject * obj0 = 0 ;
24563 char *kwnames[] = {
24564 (char *) "val", NULL
24565 };
24566
24567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
24568 {
24569 arg1 = static_cast<long >(SWIG_As_long(obj0));
24570 if (SWIG_arg_fail(1)) SWIG_fail;
24571 }
24572 {
24573 PyThreadState* __tstate = wxPyBeginAllowThreads();
24574 wxPyApp::SetMacExitMenuItemId(arg1);
24575
24576 wxPyEndAllowThreads(__tstate);
24577 if (PyErr_Occurred()) SWIG_fail;
24578 }
24579 Py_INCREF(Py_None); resultobj = Py_None;
24580 return resultobj;
24581 fail:
24582 return NULL;
24583 }
24584
24585
24586 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24587 PyObject *resultobj = NULL;
24588 wxString *arg1 = 0 ;
24589 bool temp1 = false ;
24590 PyObject * obj0 = 0 ;
24591 char *kwnames[] = {
24592 (char *) "val", NULL
24593 };
24594
24595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
24596 {
24597 arg1 = wxString_in_helper(obj0);
24598 if (arg1 == NULL) SWIG_fail;
24599 temp1 = true;
24600 }
24601 {
24602 PyThreadState* __tstate = wxPyBeginAllowThreads();
24603 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
24604
24605 wxPyEndAllowThreads(__tstate);
24606 if (PyErr_Occurred()) SWIG_fail;
24607 }
24608 Py_INCREF(Py_None); resultobj = Py_None;
24609 {
24610 if (temp1)
24611 delete arg1;
24612 }
24613 return resultobj;
24614 fail:
24615 {
24616 if (temp1)
24617 delete arg1;
24618 }
24619 return NULL;
24620 }
24621
24622
24623 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
24624 PyObject *resultobj = NULL;
24625 wxPyApp *arg1 = (wxPyApp *) 0 ;
24626 PyObject * obj0 = 0 ;
24627 char *kwnames[] = {
24628 (char *) "self", NULL
24629 };
24630
24631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
24632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24633 if (SWIG_arg_fail(1)) SWIG_fail;
24634 {
24635 PyThreadState* __tstate = wxPyBeginAllowThreads();
24636 (arg1)->_BootstrapApp();
24637
24638 wxPyEndAllowThreads(__tstate);
24639 if (PyErr_Occurred()) SWIG_fail;
24640 }
24641 Py_INCREF(Py_None); resultobj = Py_None;
24642 return resultobj;
24643 fail:
24644 return NULL;
24645 }
24646
24647
24648 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
24649 PyObject *resultobj = NULL;
24650 int result;
24651 char *kwnames[] = {
24652 NULL
24653 };
24654
24655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
24656 {
24657 PyThreadState* __tstate = wxPyBeginAllowThreads();
24658 result = (int)wxPyApp::GetComCtl32Version();
24659
24660 wxPyEndAllowThreads(__tstate);
24661 if (PyErr_Occurred()) SWIG_fail;
24662 }
24663 {
24664 resultobj = SWIG_From_int(static_cast<int >(result));
24665 }
24666 return resultobj;
24667 fail:
24668 return NULL;
24669 }
24670
24671
24672 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
24673 PyObject *obj;
24674 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24675 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
24676 Py_INCREF(obj);
24677 return Py_BuildValue((char *)"");
24678 }
24679 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24680 PyObject *resultobj = NULL;
24681 char *kwnames[] = {
24682 NULL
24683 };
24684
24685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
24686 {
24687 PyThreadState* __tstate = wxPyBeginAllowThreads();
24688 wxExit();
24689
24690 wxPyEndAllowThreads(__tstate);
24691 if (PyErr_Occurred()) SWIG_fail;
24692 }
24693 Py_INCREF(Py_None); resultobj = Py_None;
24694 return resultobj;
24695 fail:
24696 return NULL;
24697 }
24698
24699
24700 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
24701 PyObject *resultobj = NULL;
24702 bool result;
24703 char *kwnames[] = {
24704 NULL
24705 };
24706
24707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
24708 {
24709 PyThreadState* __tstate = wxPyBeginAllowThreads();
24710 result = (bool)wxYield();
24711
24712 wxPyEndAllowThreads(__tstate);
24713 if (PyErr_Occurred()) SWIG_fail;
24714 }
24715 {
24716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24717 }
24718 return resultobj;
24719 fail:
24720 return NULL;
24721 }
24722
24723
24724 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
24725 PyObject *resultobj = NULL;
24726 bool result;
24727 char *kwnames[] = {
24728 NULL
24729 };
24730
24731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
24732 {
24733 PyThreadState* __tstate = wxPyBeginAllowThreads();
24734 result = (bool)wxYieldIfNeeded();
24735
24736 wxPyEndAllowThreads(__tstate);
24737 if (PyErr_Occurred()) SWIG_fail;
24738 }
24739 {
24740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24741 }
24742 return resultobj;
24743 fail:
24744 return NULL;
24745 }
24746
24747
24748 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
24749 PyObject *resultobj = NULL;
24750 wxWindow *arg1 = (wxWindow *) NULL ;
24751 bool arg2 = (bool) false ;
24752 bool result;
24753 PyObject * obj0 = 0 ;
24754 PyObject * obj1 = 0 ;
24755 char *kwnames[] = {
24756 (char *) "win",(char *) "onlyIfNeeded", NULL
24757 };
24758
24759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24760 if (obj0) {
24761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24762 if (SWIG_arg_fail(1)) SWIG_fail;
24763 }
24764 if (obj1) {
24765 {
24766 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
24767 if (SWIG_arg_fail(2)) SWIG_fail;
24768 }
24769 }
24770 {
24771 PyThreadState* __tstate = wxPyBeginAllowThreads();
24772 result = (bool)wxSafeYield(arg1,arg2);
24773
24774 wxPyEndAllowThreads(__tstate);
24775 if (PyErr_Occurred()) SWIG_fail;
24776 }
24777 {
24778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24779 }
24780 return resultobj;
24781 fail:
24782 return NULL;
24783 }
24784
24785
24786 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24787 PyObject *resultobj = NULL;
24788 char *kwnames[] = {
24789 NULL
24790 };
24791
24792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24793 {
24794 PyThreadState* __tstate = wxPyBeginAllowThreads();
24795 wxWakeUpIdle();
24796
24797 wxPyEndAllowThreads(__tstate);
24798 if (PyErr_Occurred()) SWIG_fail;
24799 }
24800 Py_INCREF(Py_None); resultobj = Py_None;
24801 return resultobj;
24802 fail:
24803 return NULL;
24804 }
24805
24806
24807 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24808 PyObject *resultobj = NULL;
24809 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24810 wxEvent *arg2 = 0 ;
24811 PyObject * obj0 = 0 ;
24812 PyObject * obj1 = 0 ;
24813 char *kwnames[] = {
24814 (char *) "dest",(char *) "event", NULL
24815 };
24816
24817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24819 if (SWIG_arg_fail(1)) SWIG_fail;
24820 {
24821 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24822 if (SWIG_arg_fail(2)) SWIG_fail;
24823 if (arg2 == NULL) {
24824 SWIG_null_ref("wxEvent");
24825 }
24826 if (SWIG_arg_fail(2)) SWIG_fail;
24827 }
24828 {
24829 PyThreadState* __tstate = wxPyBeginAllowThreads();
24830 wxPostEvent(arg1,*arg2);
24831
24832 wxPyEndAllowThreads(__tstate);
24833 if (PyErr_Occurred()) SWIG_fail;
24834 }
24835 Py_INCREF(Py_None); resultobj = Py_None;
24836 return resultobj;
24837 fail:
24838 return NULL;
24839 }
24840
24841
24842 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24843 PyObject *resultobj = NULL;
24844 char *kwnames[] = {
24845 NULL
24846 };
24847
24848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24849 {
24850 PyThreadState* __tstate = wxPyBeginAllowThreads();
24851 wxApp_CleanUp();
24852
24853 wxPyEndAllowThreads(__tstate);
24854 if (PyErr_Occurred()) SWIG_fail;
24855 }
24856 Py_INCREF(Py_None); resultobj = Py_None;
24857 return resultobj;
24858 fail:
24859 return NULL;
24860 }
24861
24862
24863 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24864 PyObject *resultobj = NULL;
24865 wxPyApp *result;
24866 char *kwnames[] = {
24867 NULL
24868 };
24869
24870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24871 {
24872 PyThreadState* __tstate = wxPyBeginAllowThreads();
24873 result = (wxPyApp *)wxPyGetApp();
24874
24875 wxPyEndAllowThreads(__tstate);
24876 if (PyErr_Occurred()) SWIG_fail;
24877 }
24878 {
24879 resultobj = wxPyMake_wxObject(result, 0);
24880 }
24881 return resultobj;
24882 fail:
24883 return NULL;
24884 }
24885
24886
24887 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24888 PyObject *resultobj = NULL;
24889 char *arg1 = (char *) 0 ;
24890 PyObject * obj0 = 0 ;
24891 char *kwnames[] = {
24892 (char *) "encoding", NULL
24893 };
24894
24895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24896 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24897 SWIG_arg_fail(1);SWIG_fail;
24898 }
24899 {
24900 PyThreadState* __tstate = wxPyBeginAllowThreads();
24901 wxSetDefaultPyEncoding((char const *)arg1);
24902
24903 wxPyEndAllowThreads(__tstate);
24904 if (PyErr_Occurred()) SWIG_fail;
24905 }
24906 Py_INCREF(Py_None); resultobj = Py_None;
24907 return resultobj;
24908 fail:
24909 return NULL;
24910 }
24911
24912
24913 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24914 PyObject *resultobj = NULL;
24915 char *result;
24916 char *kwnames[] = {
24917 NULL
24918 };
24919
24920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24921 {
24922 PyThreadState* __tstate = wxPyBeginAllowThreads();
24923 result = (char *)wxGetDefaultPyEncoding();
24924
24925 wxPyEndAllowThreads(__tstate);
24926 if (PyErr_Occurred()) SWIG_fail;
24927 }
24928 resultobj = SWIG_FromCharPtr(result);
24929 return resultobj;
24930 fail:
24931 return NULL;
24932 }
24933
24934
24935 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24936 PyObject *resultobj = NULL;
24937 wxEventLoop *result;
24938 char *kwnames[] = {
24939 NULL
24940 };
24941
24942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24943 {
24944 PyThreadState* __tstate = wxPyBeginAllowThreads();
24945 result = (wxEventLoop *)new wxEventLoop();
24946
24947 wxPyEndAllowThreads(__tstate);
24948 if (PyErr_Occurred()) SWIG_fail;
24949 }
24950 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24951 return resultobj;
24952 fail:
24953 return NULL;
24954 }
24955
24956
24957 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24958 PyObject *resultobj = NULL;
24959 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24960 PyObject * obj0 = 0 ;
24961 char *kwnames[] = {
24962 (char *) "self", NULL
24963 };
24964
24965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24967 if (SWIG_arg_fail(1)) SWIG_fail;
24968 {
24969 PyThreadState* __tstate = wxPyBeginAllowThreads();
24970 delete arg1;
24971
24972 wxPyEndAllowThreads(__tstate);
24973 if (PyErr_Occurred()) SWIG_fail;
24974 }
24975 Py_INCREF(Py_None); resultobj = Py_None;
24976 return resultobj;
24977 fail:
24978 return NULL;
24979 }
24980
24981
24982 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24983 PyObject *resultobj = NULL;
24984 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24985 int result;
24986 PyObject * obj0 = 0 ;
24987 char *kwnames[] = {
24988 (char *) "self", NULL
24989 };
24990
24991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24993 if (SWIG_arg_fail(1)) SWIG_fail;
24994 {
24995 PyThreadState* __tstate = wxPyBeginAllowThreads();
24996 result = (int)(arg1)->Run();
24997
24998 wxPyEndAllowThreads(__tstate);
24999 if (PyErr_Occurred()) SWIG_fail;
25000 }
25001 {
25002 resultobj = SWIG_From_int(static_cast<int >(result));
25003 }
25004 return resultobj;
25005 fail:
25006 return NULL;
25007 }
25008
25009
25010 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
25011 PyObject *resultobj = NULL;
25012 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25013 int arg2 = (int) 0 ;
25014 PyObject * obj0 = 0 ;
25015 PyObject * obj1 = 0 ;
25016 char *kwnames[] = {
25017 (char *) "self",(char *) "rc", NULL
25018 };
25019
25020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
25021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25022 if (SWIG_arg_fail(1)) SWIG_fail;
25023 if (obj1) {
25024 {
25025 arg2 = static_cast<int >(SWIG_As_int(obj1));
25026 if (SWIG_arg_fail(2)) SWIG_fail;
25027 }
25028 }
25029 {
25030 PyThreadState* __tstate = wxPyBeginAllowThreads();
25031 (arg1)->Exit(arg2);
25032
25033 wxPyEndAllowThreads(__tstate);
25034 if (PyErr_Occurred()) SWIG_fail;
25035 }
25036 Py_INCREF(Py_None); resultobj = Py_None;
25037 return resultobj;
25038 fail:
25039 return NULL;
25040 }
25041
25042
25043 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
25044 PyObject *resultobj = NULL;
25045 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25046 bool result;
25047 PyObject * obj0 = 0 ;
25048 char *kwnames[] = {
25049 (char *) "self", NULL
25050 };
25051
25052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
25053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25054 if (SWIG_arg_fail(1)) SWIG_fail;
25055 {
25056 PyThreadState* __tstate = wxPyBeginAllowThreads();
25057 result = (bool)((wxEventLoop const *)arg1)->Pending();
25058
25059 wxPyEndAllowThreads(__tstate);
25060 if (PyErr_Occurred()) SWIG_fail;
25061 }
25062 {
25063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25064 }
25065 return resultobj;
25066 fail:
25067 return NULL;
25068 }
25069
25070
25071 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
25072 PyObject *resultobj = NULL;
25073 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25074 bool result;
25075 PyObject * obj0 = 0 ;
25076 char *kwnames[] = {
25077 (char *) "self", NULL
25078 };
25079
25080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
25081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25082 if (SWIG_arg_fail(1)) SWIG_fail;
25083 {
25084 PyThreadState* __tstate = wxPyBeginAllowThreads();
25085 result = (bool)(arg1)->Dispatch();
25086
25087 wxPyEndAllowThreads(__tstate);
25088 if (PyErr_Occurred()) SWIG_fail;
25089 }
25090 {
25091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25092 }
25093 return resultobj;
25094 fail:
25095 return NULL;
25096 }
25097
25098
25099 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
25100 PyObject *resultobj = NULL;
25101 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25102 bool result;
25103 PyObject * obj0 = 0 ;
25104 char *kwnames[] = {
25105 (char *) "self", NULL
25106 };
25107
25108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
25109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25110 if (SWIG_arg_fail(1)) SWIG_fail;
25111 {
25112 PyThreadState* __tstate = wxPyBeginAllowThreads();
25113 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
25114
25115 wxPyEndAllowThreads(__tstate);
25116 if (PyErr_Occurred()) SWIG_fail;
25117 }
25118 {
25119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25120 }
25121 return resultobj;
25122 fail:
25123 return NULL;
25124 }
25125
25126
25127 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
25128 PyObject *resultobj = NULL;
25129 wxEventLoop *result;
25130 char *kwnames[] = {
25131 NULL
25132 };
25133
25134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
25135 {
25136 PyThreadState* __tstate = wxPyBeginAllowThreads();
25137 result = (wxEventLoop *)wxEventLoop::GetActive();
25138
25139 wxPyEndAllowThreads(__tstate);
25140 if (PyErr_Occurred()) SWIG_fail;
25141 }
25142 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
25143 return resultobj;
25144 fail:
25145 return NULL;
25146 }
25147
25148
25149 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
25150 PyObject *resultobj = NULL;
25151 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25152 PyObject * obj0 = 0 ;
25153 char *kwnames[] = {
25154 (char *) "loop", NULL
25155 };
25156
25157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
25158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25159 if (SWIG_arg_fail(1)) SWIG_fail;
25160 {
25161 PyThreadState* __tstate = wxPyBeginAllowThreads();
25162 wxEventLoop::SetActive(arg1);
25163
25164 wxPyEndAllowThreads(__tstate);
25165 if (PyErr_Occurred()) SWIG_fail;
25166 }
25167 Py_INCREF(Py_None); resultobj = Py_None;
25168 return resultobj;
25169 fail:
25170 return NULL;
25171 }
25172
25173
25174 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
25175 PyObject *obj;
25176 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25177 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
25178 Py_INCREF(obj);
25179 return Py_BuildValue((char *)"");
25180 }
25181 static PyObject *_wrap_new_EventLoopActivator(PyObject *, PyObject *args, PyObject *kwargs) {
25182 PyObject *resultobj = NULL;
25183 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
25184 wxEventLoopActivator *result;
25185 PyObject * obj0 = 0 ;
25186 char *kwnames[] = {
25187 (char *) "evtLoop", NULL
25188 };
25189
25190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) goto fail;
25191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
25192 if (SWIG_arg_fail(1)) SWIG_fail;
25193 {
25194 PyThreadState* __tstate = wxPyBeginAllowThreads();
25195 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
25196
25197 wxPyEndAllowThreads(__tstate);
25198 if (PyErr_Occurred()) SWIG_fail;
25199 }
25200 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoopActivator, 1);
25201 return resultobj;
25202 fail:
25203 return NULL;
25204 }
25205
25206
25207 static PyObject *_wrap_delete_EventLoopActivator(PyObject *, PyObject *args, PyObject *kwargs) {
25208 PyObject *resultobj = NULL;
25209 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
25210 PyObject * obj0 = 0 ;
25211 char *kwnames[] = {
25212 (char *) "self", NULL
25213 };
25214
25215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoopActivator",kwnames,&obj0)) goto fail;
25216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_EXCEPTION | 0);
25217 if (SWIG_arg_fail(1)) SWIG_fail;
25218 {
25219 PyThreadState* __tstate = wxPyBeginAllowThreads();
25220 delete arg1;
25221
25222 wxPyEndAllowThreads(__tstate);
25223 if (PyErr_Occurred()) SWIG_fail;
25224 }
25225 Py_INCREF(Py_None); resultobj = Py_None;
25226 return resultobj;
25227 fail:
25228 return NULL;
25229 }
25230
25231
25232 static PyObject * EventLoopActivator_swigregister(PyObject *, PyObject *args) {
25233 PyObject *obj;
25234 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25235 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoopActivator, obj);
25236 Py_INCREF(obj);
25237 return Py_BuildValue((char *)"");
25238 }
25239 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25240 PyObject *resultobj = NULL;
25241 int arg1 = (int) 0 ;
25242 int arg2 = (int) 0 ;
25243 int arg3 = (int) 0 ;
25244 wxAcceleratorEntry *result;
25245 PyObject * obj0 = 0 ;
25246 PyObject * obj1 = 0 ;
25247 PyObject * obj2 = 0 ;
25248 char *kwnames[] = {
25249 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
25250 };
25251
25252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
25253 if (obj0) {
25254 {
25255 arg1 = static_cast<int >(SWIG_As_int(obj0));
25256 if (SWIG_arg_fail(1)) SWIG_fail;
25257 }
25258 }
25259 if (obj1) {
25260 {
25261 arg2 = static_cast<int >(SWIG_As_int(obj1));
25262 if (SWIG_arg_fail(2)) SWIG_fail;
25263 }
25264 }
25265 if (obj2) {
25266 {
25267 arg3 = static_cast<int >(SWIG_As_int(obj2));
25268 if (SWIG_arg_fail(3)) SWIG_fail;
25269 }
25270 }
25271 {
25272 PyThreadState* __tstate = wxPyBeginAllowThreads();
25273 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
25274
25275 wxPyEndAllowThreads(__tstate);
25276 if (PyErr_Occurred()) SWIG_fail;
25277 }
25278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
25279 return resultobj;
25280 fail:
25281 return NULL;
25282 }
25283
25284
25285 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
25286 PyObject *resultobj = NULL;
25287 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25288 PyObject * obj0 = 0 ;
25289 char *kwnames[] = {
25290 (char *) "self", NULL
25291 };
25292
25293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
25294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25295 if (SWIG_arg_fail(1)) SWIG_fail;
25296 {
25297 PyThreadState* __tstate = wxPyBeginAllowThreads();
25298 delete arg1;
25299
25300 wxPyEndAllowThreads(__tstate);
25301 if (PyErr_Occurred()) SWIG_fail;
25302 }
25303 Py_INCREF(Py_None); resultobj = Py_None;
25304 return resultobj;
25305 fail:
25306 return NULL;
25307 }
25308
25309
25310 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
25311 PyObject *resultobj = NULL;
25312 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25313 int arg2 ;
25314 int arg3 ;
25315 int arg4 ;
25316 PyObject * obj0 = 0 ;
25317 PyObject * obj1 = 0 ;
25318 PyObject * obj2 = 0 ;
25319 PyObject * obj3 = 0 ;
25320 char *kwnames[] = {
25321 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
25322 };
25323
25324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25326 if (SWIG_arg_fail(1)) SWIG_fail;
25327 {
25328 arg2 = static_cast<int >(SWIG_As_int(obj1));
25329 if (SWIG_arg_fail(2)) SWIG_fail;
25330 }
25331 {
25332 arg3 = static_cast<int >(SWIG_As_int(obj2));
25333 if (SWIG_arg_fail(3)) SWIG_fail;
25334 }
25335 {
25336 arg4 = static_cast<int >(SWIG_As_int(obj3));
25337 if (SWIG_arg_fail(4)) SWIG_fail;
25338 }
25339 {
25340 PyThreadState* __tstate = wxPyBeginAllowThreads();
25341 (arg1)->Set(arg2,arg3,arg4);
25342
25343 wxPyEndAllowThreads(__tstate);
25344 if (PyErr_Occurred()) SWIG_fail;
25345 }
25346 Py_INCREF(Py_None); resultobj = Py_None;
25347 return resultobj;
25348 fail:
25349 return NULL;
25350 }
25351
25352
25353 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
25354 PyObject *resultobj = NULL;
25355 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25356 int result;
25357 PyObject * obj0 = 0 ;
25358 char *kwnames[] = {
25359 (char *) "self", NULL
25360 };
25361
25362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
25363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25364 if (SWIG_arg_fail(1)) SWIG_fail;
25365 {
25366 PyThreadState* __tstate = wxPyBeginAllowThreads();
25367 result = (int)(arg1)->GetFlags();
25368
25369 wxPyEndAllowThreads(__tstate);
25370 if (PyErr_Occurred()) SWIG_fail;
25371 }
25372 {
25373 resultobj = SWIG_From_int(static_cast<int >(result));
25374 }
25375 return resultobj;
25376 fail:
25377 return NULL;
25378 }
25379
25380
25381 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
25382 PyObject *resultobj = NULL;
25383 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25384 int result;
25385 PyObject * obj0 = 0 ;
25386 char *kwnames[] = {
25387 (char *) "self", NULL
25388 };
25389
25390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
25391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25392 if (SWIG_arg_fail(1)) SWIG_fail;
25393 {
25394 PyThreadState* __tstate = wxPyBeginAllowThreads();
25395 result = (int)(arg1)->GetKeyCode();
25396
25397 wxPyEndAllowThreads(__tstate);
25398 if (PyErr_Occurred()) SWIG_fail;
25399 }
25400 {
25401 resultobj = SWIG_From_int(static_cast<int >(result));
25402 }
25403 return resultobj;
25404 fail:
25405 return NULL;
25406 }
25407
25408
25409 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
25410 PyObject *resultobj = NULL;
25411 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25412 int result;
25413 PyObject * obj0 = 0 ;
25414 char *kwnames[] = {
25415 (char *) "self", NULL
25416 };
25417
25418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
25419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25420 if (SWIG_arg_fail(1)) SWIG_fail;
25421 {
25422 PyThreadState* __tstate = wxPyBeginAllowThreads();
25423 result = (int)(arg1)->GetCommand();
25424
25425 wxPyEndAllowThreads(__tstate);
25426 if (PyErr_Occurred()) SWIG_fail;
25427 }
25428 {
25429 resultobj = SWIG_From_int(static_cast<int >(result));
25430 }
25431 return resultobj;
25432 fail:
25433 return NULL;
25434 }
25435
25436
25437 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
25438 PyObject *obj;
25439 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25440 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
25441 Py_INCREF(obj);
25442 return Py_BuildValue((char *)"");
25443 }
25444 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25445 PyObject *resultobj = NULL;
25446 int arg1 ;
25447 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
25448 wxAcceleratorTable *result;
25449 PyObject * obj0 = 0 ;
25450 char *kwnames[] = {
25451 (char *) "n", NULL
25452 };
25453
25454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
25455 {
25456 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
25457 if (arg2) arg1 = PyList_Size(obj0);
25458 else arg1 = 0;
25459 }
25460 {
25461 PyThreadState* __tstate = wxPyBeginAllowThreads();
25462 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
25463
25464 wxPyEndAllowThreads(__tstate);
25465 if (PyErr_Occurred()) SWIG_fail;
25466 }
25467 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
25468 {
25469 delete [] arg2;
25470 }
25471 return resultobj;
25472 fail:
25473 {
25474 delete [] arg2;
25475 }
25476 return NULL;
25477 }
25478
25479
25480 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25481 PyObject *resultobj = NULL;
25482 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25483 PyObject * obj0 = 0 ;
25484 char *kwnames[] = {
25485 (char *) "self", NULL
25486 };
25487
25488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
25489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25490 if (SWIG_arg_fail(1)) SWIG_fail;
25491 {
25492 PyThreadState* __tstate = wxPyBeginAllowThreads();
25493 delete arg1;
25494
25495 wxPyEndAllowThreads(__tstate);
25496 if (PyErr_Occurred()) SWIG_fail;
25497 }
25498 Py_INCREF(Py_None); resultobj = Py_None;
25499 return resultobj;
25500 fail:
25501 return NULL;
25502 }
25503
25504
25505 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
25506 PyObject *resultobj = NULL;
25507 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25508 bool result;
25509 PyObject * obj0 = 0 ;
25510 char *kwnames[] = {
25511 (char *) "self", NULL
25512 };
25513
25514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
25515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25516 if (SWIG_arg_fail(1)) SWIG_fail;
25517 {
25518 PyThreadState* __tstate = wxPyBeginAllowThreads();
25519 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
25520
25521 wxPyEndAllowThreads(__tstate);
25522 if (PyErr_Occurred()) SWIG_fail;
25523 }
25524 {
25525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25526 }
25527 return resultobj;
25528 fail:
25529 return NULL;
25530 }
25531
25532
25533 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
25534 PyObject *obj;
25535 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25536 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
25537 Py_INCREF(obj);
25538 return Py_BuildValue((char *)"");
25539 }
25540 static int _wrap_NullAcceleratorTable_set(PyObject *) {
25541 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
25542 return 1;
25543 }
25544
25545
25546 static PyObject *_wrap_NullAcceleratorTable_get(void) {
25547 PyObject *pyobj = NULL;
25548
25549 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
25550 return pyobj;
25551 }
25552
25553
25554 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
25555 PyObject *resultobj = NULL;
25556 wxString *arg1 = 0 ;
25557 wxAcceleratorEntry *result;
25558 bool temp1 = false ;
25559 PyObject * obj0 = 0 ;
25560 char *kwnames[] = {
25561 (char *) "label", NULL
25562 };
25563
25564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
25565 {
25566 arg1 = wxString_in_helper(obj0);
25567 if (arg1 == NULL) SWIG_fail;
25568 temp1 = true;
25569 }
25570 {
25571 PyThreadState* __tstate = wxPyBeginAllowThreads();
25572 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
25573
25574 wxPyEndAllowThreads(__tstate);
25575 if (PyErr_Occurred()) SWIG_fail;
25576 }
25577 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
25578 {
25579 if (temp1)
25580 delete arg1;
25581 }
25582 return resultobj;
25583 fail:
25584 {
25585 if (temp1)
25586 delete arg1;
25587 }
25588 return NULL;
25589 }
25590
25591
25592 static int _wrap_PanelNameStr_set(PyObject *) {
25593 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
25594 return 1;
25595 }
25596
25597
25598 static PyObject *_wrap_PanelNameStr_get(void) {
25599 PyObject *pyobj = NULL;
25600
25601 {
25602 #if wxUSE_UNICODE
25603 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25604 #else
25605 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25606 #endif
25607 }
25608 return pyobj;
25609 }
25610
25611
25612 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25613 PyObject *resultobj = NULL;
25614 wxVisualAttributes *result;
25615 char *kwnames[] = {
25616 NULL
25617 };
25618
25619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
25620 {
25621 PyThreadState* __tstate = wxPyBeginAllowThreads();
25622 result = (wxVisualAttributes *)new_wxVisualAttributes();
25623
25624 wxPyEndAllowThreads(__tstate);
25625 if (PyErr_Occurred()) SWIG_fail;
25626 }
25627 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
25628 return resultobj;
25629 fail:
25630 return NULL;
25631 }
25632
25633
25634 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25635 PyObject *resultobj = NULL;
25636 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25637 PyObject * obj0 = 0 ;
25638 char *kwnames[] = {
25639 (char *) "self", NULL
25640 };
25641
25642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
25643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25644 if (SWIG_arg_fail(1)) SWIG_fail;
25645 {
25646 PyThreadState* __tstate = wxPyBeginAllowThreads();
25647 delete_wxVisualAttributes(arg1);
25648
25649 wxPyEndAllowThreads(__tstate);
25650 if (PyErr_Occurred()) SWIG_fail;
25651 }
25652 Py_INCREF(Py_None); resultobj = Py_None;
25653 return resultobj;
25654 fail:
25655 return NULL;
25656 }
25657
25658
25659 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
25660 PyObject *resultobj = NULL;
25661 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25662 wxFont *arg2 = (wxFont *) 0 ;
25663 PyObject * obj0 = 0 ;
25664 PyObject * obj1 = 0 ;
25665 char *kwnames[] = {
25666 (char *) "self",(char *) "font", NULL
25667 };
25668
25669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
25670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25671 if (SWIG_arg_fail(1)) SWIG_fail;
25672 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
25673 if (SWIG_arg_fail(2)) SWIG_fail;
25674 if (arg1) (arg1)->font = *arg2;
25675
25676 Py_INCREF(Py_None); resultobj = Py_None;
25677 return resultobj;
25678 fail:
25679 return NULL;
25680 }
25681
25682
25683 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
25684 PyObject *resultobj = NULL;
25685 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25686 wxFont *result;
25687 PyObject * obj0 = 0 ;
25688 char *kwnames[] = {
25689 (char *) "self", NULL
25690 };
25691
25692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
25693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25694 if (SWIG_arg_fail(1)) SWIG_fail;
25695 result = (wxFont *)& ((arg1)->font);
25696
25697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
25698 return resultobj;
25699 fail:
25700 return NULL;
25701 }
25702
25703
25704 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25705 PyObject *resultobj = NULL;
25706 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25707 wxColour *arg2 = (wxColour *) 0 ;
25708 PyObject * obj0 = 0 ;
25709 PyObject * obj1 = 0 ;
25710 char *kwnames[] = {
25711 (char *) "self",(char *) "colFg", NULL
25712 };
25713
25714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
25715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25716 if (SWIG_arg_fail(1)) SWIG_fail;
25717 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25718 if (SWIG_arg_fail(2)) SWIG_fail;
25719 if (arg1) (arg1)->colFg = *arg2;
25720
25721 Py_INCREF(Py_None); resultobj = Py_None;
25722 return resultobj;
25723 fail:
25724 return NULL;
25725 }
25726
25727
25728 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25729 PyObject *resultobj = NULL;
25730 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25731 wxColour *result;
25732 PyObject * obj0 = 0 ;
25733 char *kwnames[] = {
25734 (char *) "self", NULL
25735 };
25736
25737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
25738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25739 if (SWIG_arg_fail(1)) SWIG_fail;
25740 result = (wxColour *)& ((arg1)->colFg);
25741
25742 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25743 return resultobj;
25744 fail:
25745 return NULL;
25746 }
25747
25748
25749 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25750 PyObject *resultobj = NULL;
25751 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25752 wxColour *arg2 = (wxColour *) 0 ;
25753 PyObject * obj0 = 0 ;
25754 PyObject * obj1 = 0 ;
25755 char *kwnames[] = {
25756 (char *) "self",(char *) "colBg", NULL
25757 };
25758
25759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
25760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25761 if (SWIG_arg_fail(1)) SWIG_fail;
25762 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25763 if (SWIG_arg_fail(2)) SWIG_fail;
25764 if (arg1) (arg1)->colBg = *arg2;
25765
25766 Py_INCREF(Py_None); resultobj = Py_None;
25767 return resultobj;
25768 fail:
25769 return NULL;
25770 }
25771
25772
25773 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25774 PyObject *resultobj = NULL;
25775 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25776 wxColour *result;
25777 PyObject * obj0 = 0 ;
25778 char *kwnames[] = {
25779 (char *) "self", NULL
25780 };
25781
25782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
25783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25784 if (SWIG_arg_fail(1)) SWIG_fail;
25785 result = (wxColour *)& ((arg1)->colBg);
25786
25787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25788 return resultobj;
25789 fail:
25790 return NULL;
25791 }
25792
25793
25794 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
25795 PyObject *obj;
25796 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25797 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
25798 Py_INCREF(obj);
25799 return Py_BuildValue((char *)"");
25800 }
25801 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
25802 PyObject *resultobj = NULL;
25803 wxWindow *arg1 = (wxWindow *) 0 ;
25804 int arg2 = (int) (int)-1 ;
25805 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25806 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25807 wxSize const &arg4_defvalue = wxDefaultSize ;
25808 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25809 long arg5 = (long) 0 ;
25810 wxString const &arg6_defvalue = wxPyPanelNameStr ;
25811 wxString *arg6 = (wxString *) &arg6_defvalue ;
25812 wxWindow *result;
25813 wxPoint temp3 ;
25814 wxSize temp4 ;
25815 bool temp6 = false ;
25816 PyObject * obj0 = 0 ;
25817 PyObject * obj1 = 0 ;
25818 PyObject * obj2 = 0 ;
25819 PyObject * obj3 = 0 ;
25820 PyObject * obj4 = 0 ;
25821 PyObject * obj5 = 0 ;
25822 char *kwnames[] = {
25823 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25824 };
25825
25826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25828 if (SWIG_arg_fail(1)) SWIG_fail;
25829 if (obj1) {
25830 {
25831 arg2 = static_cast<int const >(SWIG_As_int(obj1));
25832 if (SWIG_arg_fail(2)) SWIG_fail;
25833 }
25834 }
25835 if (obj2) {
25836 {
25837 arg3 = &temp3;
25838 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25839 }
25840 }
25841 if (obj3) {
25842 {
25843 arg4 = &temp4;
25844 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25845 }
25846 }
25847 if (obj4) {
25848 {
25849 arg5 = static_cast<long >(SWIG_As_long(obj4));
25850 if (SWIG_arg_fail(5)) SWIG_fail;
25851 }
25852 }
25853 if (obj5) {
25854 {
25855 arg6 = wxString_in_helper(obj5);
25856 if (arg6 == NULL) SWIG_fail;
25857 temp6 = true;
25858 }
25859 }
25860 {
25861 if (!wxPyCheckForApp()) SWIG_fail;
25862 PyThreadState* __tstate = wxPyBeginAllowThreads();
25863 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25864
25865 wxPyEndAllowThreads(__tstate);
25866 if (PyErr_Occurred()) SWIG_fail;
25867 }
25868 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25869 {
25870 if (temp6)
25871 delete arg6;
25872 }
25873 return resultobj;
25874 fail:
25875 {
25876 if (temp6)
25877 delete arg6;
25878 }
25879 return NULL;
25880 }
25881
25882
25883 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25884 PyObject *resultobj = NULL;
25885 wxWindow *result;
25886 char *kwnames[] = {
25887 NULL
25888 };
25889
25890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25891 {
25892 if (!wxPyCheckForApp()) SWIG_fail;
25893 PyThreadState* __tstate = wxPyBeginAllowThreads();
25894 result = (wxWindow *)new wxWindow();
25895
25896 wxPyEndAllowThreads(__tstate);
25897 if (PyErr_Occurred()) SWIG_fail;
25898 }
25899 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25900 return resultobj;
25901 fail:
25902 return NULL;
25903 }
25904
25905
25906 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25907 PyObject *resultobj = NULL;
25908 wxWindow *arg1 = (wxWindow *) 0 ;
25909 wxWindow *arg2 = (wxWindow *) 0 ;
25910 int arg3 = (int) (int)-1 ;
25911 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25912 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25913 wxSize const &arg5_defvalue = wxDefaultSize ;
25914 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25915 long arg6 = (long) 0 ;
25916 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25917 wxString *arg7 = (wxString *) &arg7_defvalue ;
25918 bool result;
25919 wxPoint temp4 ;
25920 wxSize temp5 ;
25921 bool temp7 = false ;
25922 PyObject * obj0 = 0 ;
25923 PyObject * obj1 = 0 ;
25924 PyObject * obj2 = 0 ;
25925 PyObject * obj3 = 0 ;
25926 PyObject * obj4 = 0 ;
25927 PyObject * obj5 = 0 ;
25928 PyObject * obj6 = 0 ;
25929 char *kwnames[] = {
25930 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25931 };
25932
25933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25935 if (SWIG_arg_fail(1)) SWIG_fail;
25936 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25937 if (SWIG_arg_fail(2)) SWIG_fail;
25938 if (obj2) {
25939 {
25940 arg3 = static_cast<int const >(SWIG_As_int(obj2));
25941 if (SWIG_arg_fail(3)) SWIG_fail;
25942 }
25943 }
25944 if (obj3) {
25945 {
25946 arg4 = &temp4;
25947 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25948 }
25949 }
25950 if (obj4) {
25951 {
25952 arg5 = &temp5;
25953 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25954 }
25955 }
25956 if (obj5) {
25957 {
25958 arg6 = static_cast<long >(SWIG_As_long(obj5));
25959 if (SWIG_arg_fail(6)) SWIG_fail;
25960 }
25961 }
25962 if (obj6) {
25963 {
25964 arg7 = wxString_in_helper(obj6);
25965 if (arg7 == NULL) SWIG_fail;
25966 temp7 = true;
25967 }
25968 }
25969 {
25970 PyThreadState* __tstate = wxPyBeginAllowThreads();
25971 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25972
25973 wxPyEndAllowThreads(__tstate);
25974 if (PyErr_Occurred()) SWIG_fail;
25975 }
25976 {
25977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25978 }
25979 {
25980 if (temp7)
25981 delete arg7;
25982 }
25983 return resultobj;
25984 fail:
25985 {
25986 if (temp7)
25987 delete arg7;
25988 }
25989 return NULL;
25990 }
25991
25992
25993 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25994 PyObject *resultobj = NULL;
25995 wxWindow *arg1 = (wxWindow *) 0 ;
25996 bool arg2 = (bool) false ;
25997 bool result;
25998 PyObject * obj0 = 0 ;
25999 PyObject * obj1 = 0 ;
26000 char *kwnames[] = {
26001 (char *) "self",(char *) "force", NULL
26002 };
26003
26004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
26005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26006 if (SWIG_arg_fail(1)) SWIG_fail;
26007 if (obj1) {
26008 {
26009 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
26010 if (SWIG_arg_fail(2)) SWIG_fail;
26011 }
26012 }
26013 {
26014 PyThreadState* __tstate = wxPyBeginAllowThreads();
26015 result = (bool)(arg1)->Close(arg2);
26016
26017 wxPyEndAllowThreads(__tstate);
26018 if (PyErr_Occurred()) SWIG_fail;
26019 }
26020 {
26021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26022 }
26023 return resultobj;
26024 fail:
26025 return NULL;
26026 }
26027
26028
26029 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
26030 PyObject *resultobj = NULL;
26031 wxWindow *arg1 = (wxWindow *) 0 ;
26032 bool result;
26033 PyObject * obj0 = 0 ;
26034 char *kwnames[] = {
26035 (char *) "self", NULL
26036 };
26037
26038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
26039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26040 if (SWIG_arg_fail(1)) SWIG_fail;
26041 {
26042 PyThreadState* __tstate = wxPyBeginAllowThreads();
26043 result = (bool)(arg1)->Destroy();
26044
26045 wxPyEndAllowThreads(__tstate);
26046 if (PyErr_Occurred()) SWIG_fail;
26047 }
26048 {
26049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26050 }
26051 return resultobj;
26052 fail:
26053 return NULL;
26054 }
26055
26056
26057 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
26058 PyObject *resultobj = NULL;
26059 wxWindow *arg1 = (wxWindow *) 0 ;
26060 bool result;
26061 PyObject * obj0 = 0 ;
26062 char *kwnames[] = {
26063 (char *) "self", NULL
26064 };
26065
26066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
26067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26068 if (SWIG_arg_fail(1)) SWIG_fail;
26069 {
26070 PyThreadState* __tstate = wxPyBeginAllowThreads();
26071 result = (bool)(arg1)->DestroyChildren();
26072
26073 wxPyEndAllowThreads(__tstate);
26074 if (PyErr_Occurred()) SWIG_fail;
26075 }
26076 {
26077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26078 }
26079 return resultobj;
26080 fail:
26081 return NULL;
26082 }
26083
26084
26085 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
26086 PyObject *resultobj = NULL;
26087 wxWindow *arg1 = (wxWindow *) 0 ;
26088 bool result;
26089 PyObject * obj0 = 0 ;
26090 char *kwnames[] = {
26091 (char *) "self", NULL
26092 };
26093
26094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
26095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26096 if (SWIG_arg_fail(1)) SWIG_fail;
26097 {
26098 PyThreadState* __tstate = wxPyBeginAllowThreads();
26099 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
26100
26101 wxPyEndAllowThreads(__tstate);
26102 if (PyErr_Occurred()) SWIG_fail;
26103 }
26104 {
26105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26106 }
26107 return resultobj;
26108 fail:
26109 return NULL;
26110 }
26111
26112
26113 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
26114 PyObject *resultobj = NULL;
26115 wxWindow *arg1 = (wxWindow *) 0 ;
26116 wxString *arg2 = 0 ;
26117 bool temp2 = false ;
26118 PyObject * obj0 = 0 ;
26119 PyObject * obj1 = 0 ;
26120 char *kwnames[] = {
26121 (char *) "self",(char *) "label", NULL
26122 };
26123
26124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
26125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26126 if (SWIG_arg_fail(1)) SWIG_fail;
26127 {
26128 arg2 = wxString_in_helper(obj1);
26129 if (arg2 == NULL) SWIG_fail;
26130 temp2 = true;
26131 }
26132 {
26133 PyThreadState* __tstate = wxPyBeginAllowThreads();
26134 (arg1)->SetLabel((wxString const &)*arg2);
26135
26136 wxPyEndAllowThreads(__tstate);
26137 if (PyErr_Occurred()) SWIG_fail;
26138 }
26139 Py_INCREF(Py_None); resultobj = Py_None;
26140 {
26141 if (temp2)
26142 delete arg2;
26143 }
26144 return resultobj;
26145 fail:
26146 {
26147 if (temp2)
26148 delete arg2;
26149 }
26150 return NULL;
26151 }
26152
26153
26154 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
26155 PyObject *resultobj = NULL;
26156 wxWindow *arg1 = (wxWindow *) 0 ;
26157 wxString result;
26158 PyObject * obj0 = 0 ;
26159 char *kwnames[] = {
26160 (char *) "self", NULL
26161 };
26162
26163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
26164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26165 if (SWIG_arg_fail(1)) SWIG_fail;
26166 {
26167 PyThreadState* __tstate = wxPyBeginAllowThreads();
26168 result = ((wxWindow const *)arg1)->GetLabel();
26169
26170 wxPyEndAllowThreads(__tstate);
26171 if (PyErr_Occurred()) SWIG_fail;
26172 }
26173 {
26174 #if wxUSE_UNICODE
26175 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26176 #else
26177 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26178 #endif
26179 }
26180 return resultobj;
26181 fail:
26182 return NULL;
26183 }
26184
26185
26186 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
26187 PyObject *resultobj = NULL;
26188 wxWindow *arg1 = (wxWindow *) 0 ;
26189 wxString *arg2 = 0 ;
26190 bool temp2 = false ;
26191 PyObject * obj0 = 0 ;
26192 PyObject * obj1 = 0 ;
26193 char *kwnames[] = {
26194 (char *) "self",(char *) "name", NULL
26195 };
26196
26197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
26198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26199 if (SWIG_arg_fail(1)) SWIG_fail;
26200 {
26201 arg2 = wxString_in_helper(obj1);
26202 if (arg2 == NULL) SWIG_fail;
26203 temp2 = true;
26204 }
26205 {
26206 PyThreadState* __tstate = wxPyBeginAllowThreads();
26207 (arg1)->SetName((wxString const &)*arg2);
26208
26209 wxPyEndAllowThreads(__tstate);
26210 if (PyErr_Occurred()) SWIG_fail;
26211 }
26212 Py_INCREF(Py_None); resultobj = Py_None;
26213 {
26214 if (temp2)
26215 delete arg2;
26216 }
26217 return resultobj;
26218 fail:
26219 {
26220 if (temp2)
26221 delete arg2;
26222 }
26223 return NULL;
26224 }
26225
26226
26227 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
26228 PyObject *resultobj = NULL;
26229 wxWindow *arg1 = (wxWindow *) 0 ;
26230 wxString result;
26231 PyObject * obj0 = 0 ;
26232 char *kwnames[] = {
26233 (char *) "self", NULL
26234 };
26235
26236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
26237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26238 if (SWIG_arg_fail(1)) SWIG_fail;
26239 {
26240 PyThreadState* __tstate = wxPyBeginAllowThreads();
26241 result = ((wxWindow const *)arg1)->GetName();
26242
26243 wxPyEndAllowThreads(__tstate);
26244 if (PyErr_Occurred()) SWIG_fail;
26245 }
26246 {
26247 #if wxUSE_UNICODE
26248 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26249 #else
26250 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26251 #endif
26252 }
26253 return resultobj;
26254 fail:
26255 return NULL;
26256 }
26257
26258
26259 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26260 PyObject *resultobj = NULL;
26261 wxWindow *arg1 = (wxWindow *) 0 ;
26262 wxWindowVariant arg2 ;
26263 PyObject * obj0 = 0 ;
26264 PyObject * obj1 = 0 ;
26265 char *kwnames[] = {
26266 (char *) "self",(char *) "variant", NULL
26267 };
26268
26269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
26270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26271 if (SWIG_arg_fail(1)) SWIG_fail;
26272 {
26273 arg2 = static_cast<wxWindowVariant >(SWIG_As_int(obj1));
26274 if (SWIG_arg_fail(2)) SWIG_fail;
26275 }
26276 {
26277 PyThreadState* __tstate = wxPyBeginAllowThreads();
26278 (arg1)->SetWindowVariant(arg2);
26279
26280 wxPyEndAllowThreads(__tstate);
26281 if (PyErr_Occurred()) SWIG_fail;
26282 }
26283 Py_INCREF(Py_None); resultobj = Py_None;
26284 return resultobj;
26285 fail:
26286 return NULL;
26287 }
26288
26289
26290 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
26291 PyObject *resultobj = NULL;
26292 wxWindow *arg1 = (wxWindow *) 0 ;
26293 wxWindowVariant result;
26294 PyObject * obj0 = 0 ;
26295 char *kwnames[] = {
26296 (char *) "self", NULL
26297 };
26298
26299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
26300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26301 if (SWIG_arg_fail(1)) SWIG_fail;
26302 {
26303 PyThreadState* __tstate = wxPyBeginAllowThreads();
26304 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
26305
26306 wxPyEndAllowThreads(__tstate);
26307 if (PyErr_Occurred()) SWIG_fail;
26308 }
26309 resultobj = SWIG_From_int((result));
26310 return resultobj;
26311 fail:
26312 return NULL;
26313 }
26314
26315
26316 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26317 PyObject *resultobj = NULL;
26318 wxWindow *arg1 = (wxWindow *) 0 ;
26319 int arg2 ;
26320 PyObject * obj0 = 0 ;
26321 PyObject * obj1 = 0 ;
26322 char *kwnames[] = {
26323 (char *) "self",(char *) "winid", NULL
26324 };
26325
26326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
26327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26328 if (SWIG_arg_fail(1)) SWIG_fail;
26329 {
26330 arg2 = static_cast<int >(SWIG_As_int(obj1));
26331 if (SWIG_arg_fail(2)) SWIG_fail;
26332 }
26333 {
26334 PyThreadState* __tstate = wxPyBeginAllowThreads();
26335 (arg1)->SetId(arg2);
26336
26337 wxPyEndAllowThreads(__tstate);
26338 if (PyErr_Occurred()) SWIG_fail;
26339 }
26340 Py_INCREF(Py_None); resultobj = Py_None;
26341 return resultobj;
26342 fail:
26343 return NULL;
26344 }
26345
26346
26347 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26348 PyObject *resultobj = NULL;
26349 wxWindow *arg1 = (wxWindow *) 0 ;
26350 int result;
26351 PyObject * obj0 = 0 ;
26352 char *kwnames[] = {
26353 (char *) "self", NULL
26354 };
26355
26356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
26357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26358 if (SWIG_arg_fail(1)) SWIG_fail;
26359 {
26360 PyThreadState* __tstate = wxPyBeginAllowThreads();
26361 result = (int)((wxWindow const *)arg1)->GetId();
26362
26363 wxPyEndAllowThreads(__tstate);
26364 if (PyErr_Occurred()) SWIG_fail;
26365 }
26366 {
26367 resultobj = SWIG_From_int(static_cast<int >(result));
26368 }
26369 return resultobj;
26370 fail:
26371 return NULL;
26372 }
26373
26374
26375 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26376 PyObject *resultobj = NULL;
26377 int result;
26378 char *kwnames[] = {
26379 NULL
26380 };
26381
26382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
26383 {
26384 PyThreadState* __tstate = wxPyBeginAllowThreads();
26385 result = (int)wxWindow::NewControlId();
26386
26387 wxPyEndAllowThreads(__tstate);
26388 if (PyErr_Occurred()) SWIG_fail;
26389 }
26390 {
26391 resultobj = SWIG_From_int(static_cast<int >(result));
26392 }
26393 return resultobj;
26394 fail:
26395 return NULL;
26396 }
26397
26398
26399 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26400 PyObject *resultobj = NULL;
26401 int arg1 ;
26402 int result;
26403 PyObject * obj0 = 0 ;
26404 char *kwnames[] = {
26405 (char *) "winid", NULL
26406 };
26407
26408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
26409 {
26410 arg1 = static_cast<int >(SWIG_As_int(obj0));
26411 if (SWIG_arg_fail(1)) SWIG_fail;
26412 }
26413 {
26414 PyThreadState* __tstate = wxPyBeginAllowThreads();
26415 result = (int)wxWindow::NextControlId(arg1);
26416
26417 wxPyEndAllowThreads(__tstate);
26418 if (PyErr_Occurred()) SWIG_fail;
26419 }
26420 {
26421 resultobj = SWIG_From_int(static_cast<int >(result));
26422 }
26423 return resultobj;
26424 fail:
26425 return NULL;
26426 }
26427
26428
26429 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26430 PyObject *resultobj = NULL;
26431 int arg1 ;
26432 int result;
26433 PyObject * obj0 = 0 ;
26434 char *kwnames[] = {
26435 (char *) "winid", NULL
26436 };
26437
26438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
26439 {
26440 arg1 = static_cast<int >(SWIG_As_int(obj0));
26441 if (SWIG_arg_fail(1)) SWIG_fail;
26442 }
26443 {
26444 PyThreadState* __tstate = wxPyBeginAllowThreads();
26445 result = (int)wxWindow::PrevControlId(arg1);
26446
26447 wxPyEndAllowThreads(__tstate);
26448 if (PyErr_Occurred()) SWIG_fail;
26449 }
26450 {
26451 resultobj = SWIG_From_int(static_cast<int >(result));
26452 }
26453 return resultobj;
26454 fail:
26455 return NULL;
26456 }
26457
26458
26459 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26460 PyObject *resultobj = NULL;
26461 wxWindow *arg1 = (wxWindow *) 0 ;
26462 wxSize *arg2 = 0 ;
26463 wxSize temp2 ;
26464 PyObject * obj0 = 0 ;
26465 PyObject * obj1 = 0 ;
26466 char *kwnames[] = {
26467 (char *) "self",(char *) "size", NULL
26468 };
26469
26470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
26471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26472 if (SWIG_arg_fail(1)) SWIG_fail;
26473 {
26474 arg2 = &temp2;
26475 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26476 }
26477 {
26478 PyThreadState* __tstate = wxPyBeginAllowThreads();
26479 (arg1)->SetSize((wxSize const &)*arg2);
26480
26481 wxPyEndAllowThreads(__tstate);
26482 if (PyErr_Occurred()) SWIG_fail;
26483 }
26484 Py_INCREF(Py_None); resultobj = Py_None;
26485 return resultobj;
26486 fail:
26487 return NULL;
26488 }
26489
26490
26491 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
26492 PyObject *resultobj = NULL;
26493 wxWindow *arg1 = (wxWindow *) 0 ;
26494 int arg2 ;
26495 int arg3 ;
26496 int arg4 ;
26497 int arg5 ;
26498 int arg6 = (int) wxSIZE_AUTO ;
26499 PyObject * obj0 = 0 ;
26500 PyObject * obj1 = 0 ;
26501 PyObject * obj2 = 0 ;
26502 PyObject * obj3 = 0 ;
26503 PyObject * obj4 = 0 ;
26504 PyObject * obj5 = 0 ;
26505 char *kwnames[] = {
26506 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
26507 };
26508
26509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
26510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26511 if (SWIG_arg_fail(1)) SWIG_fail;
26512 {
26513 arg2 = static_cast<int >(SWIG_As_int(obj1));
26514 if (SWIG_arg_fail(2)) SWIG_fail;
26515 }
26516 {
26517 arg3 = static_cast<int >(SWIG_As_int(obj2));
26518 if (SWIG_arg_fail(3)) SWIG_fail;
26519 }
26520 {
26521 arg4 = static_cast<int >(SWIG_As_int(obj3));
26522 if (SWIG_arg_fail(4)) SWIG_fail;
26523 }
26524 {
26525 arg5 = static_cast<int >(SWIG_As_int(obj4));
26526 if (SWIG_arg_fail(5)) SWIG_fail;
26527 }
26528 if (obj5) {
26529 {
26530 arg6 = static_cast<int >(SWIG_As_int(obj5));
26531 if (SWIG_arg_fail(6)) SWIG_fail;
26532 }
26533 }
26534 {
26535 PyThreadState* __tstate = wxPyBeginAllowThreads();
26536 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
26537
26538 wxPyEndAllowThreads(__tstate);
26539 if (PyErr_Occurred()) SWIG_fail;
26540 }
26541 Py_INCREF(Py_None); resultobj = Py_None;
26542 return resultobj;
26543 fail:
26544 return NULL;
26545 }
26546
26547
26548 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26549 PyObject *resultobj = NULL;
26550 wxWindow *arg1 = (wxWindow *) 0 ;
26551 wxRect *arg2 = 0 ;
26552 int arg3 = (int) wxSIZE_AUTO ;
26553 wxRect temp2 ;
26554 PyObject * obj0 = 0 ;
26555 PyObject * obj1 = 0 ;
26556 PyObject * obj2 = 0 ;
26557 char *kwnames[] = {
26558 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
26559 };
26560
26561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
26562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26563 if (SWIG_arg_fail(1)) SWIG_fail;
26564 {
26565 arg2 = &temp2;
26566 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26567 }
26568 if (obj2) {
26569 {
26570 arg3 = static_cast<int >(SWIG_As_int(obj2));
26571 if (SWIG_arg_fail(3)) SWIG_fail;
26572 }
26573 }
26574 {
26575 PyThreadState* __tstate = wxPyBeginAllowThreads();
26576 (arg1)->SetSize((wxRect const &)*arg2,arg3);
26577
26578 wxPyEndAllowThreads(__tstate);
26579 if (PyErr_Occurred()) SWIG_fail;
26580 }
26581 Py_INCREF(Py_None); resultobj = Py_None;
26582 return resultobj;
26583 fail:
26584 return NULL;
26585 }
26586
26587
26588 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26589 PyObject *resultobj = NULL;
26590 wxWindow *arg1 = (wxWindow *) 0 ;
26591 int arg2 ;
26592 int arg3 ;
26593 PyObject * obj0 = 0 ;
26594 PyObject * obj1 = 0 ;
26595 PyObject * obj2 = 0 ;
26596 char *kwnames[] = {
26597 (char *) "self",(char *) "width",(char *) "height", NULL
26598 };
26599
26600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26602 if (SWIG_arg_fail(1)) SWIG_fail;
26603 {
26604 arg2 = static_cast<int >(SWIG_As_int(obj1));
26605 if (SWIG_arg_fail(2)) SWIG_fail;
26606 }
26607 {
26608 arg3 = static_cast<int >(SWIG_As_int(obj2));
26609 if (SWIG_arg_fail(3)) SWIG_fail;
26610 }
26611 {
26612 PyThreadState* __tstate = wxPyBeginAllowThreads();
26613 (arg1)->SetSize(arg2,arg3);
26614
26615 wxPyEndAllowThreads(__tstate);
26616 if (PyErr_Occurred()) SWIG_fail;
26617 }
26618 Py_INCREF(Py_None); resultobj = Py_None;
26619 return resultobj;
26620 fail:
26621 return NULL;
26622 }
26623
26624
26625 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
26626 PyObject *resultobj = NULL;
26627 wxWindow *arg1 = (wxWindow *) 0 ;
26628 wxPoint *arg2 = 0 ;
26629 int arg3 = (int) wxSIZE_USE_EXISTING ;
26630 wxPoint temp2 ;
26631 PyObject * obj0 = 0 ;
26632 PyObject * obj1 = 0 ;
26633 PyObject * obj2 = 0 ;
26634 char *kwnames[] = {
26635 (char *) "self",(char *) "pt",(char *) "flags", NULL
26636 };
26637
26638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
26639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26640 if (SWIG_arg_fail(1)) SWIG_fail;
26641 {
26642 arg2 = &temp2;
26643 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26644 }
26645 if (obj2) {
26646 {
26647 arg3 = static_cast<int >(SWIG_As_int(obj2));
26648 if (SWIG_arg_fail(3)) SWIG_fail;
26649 }
26650 }
26651 {
26652 PyThreadState* __tstate = wxPyBeginAllowThreads();
26653 (arg1)->Move((wxPoint const &)*arg2,arg3);
26654
26655 wxPyEndAllowThreads(__tstate);
26656 if (PyErr_Occurred()) SWIG_fail;
26657 }
26658 Py_INCREF(Py_None); resultobj = Py_None;
26659 return resultobj;
26660 fail:
26661 return NULL;
26662 }
26663
26664
26665 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
26666 PyObject *resultobj = NULL;
26667 wxWindow *arg1 = (wxWindow *) 0 ;
26668 int arg2 ;
26669 int arg3 ;
26670 int arg4 = (int) wxSIZE_USE_EXISTING ;
26671 PyObject * obj0 = 0 ;
26672 PyObject * obj1 = 0 ;
26673 PyObject * obj2 = 0 ;
26674 PyObject * obj3 = 0 ;
26675 char *kwnames[] = {
26676 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
26677 };
26678
26679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26681 if (SWIG_arg_fail(1)) SWIG_fail;
26682 {
26683 arg2 = static_cast<int >(SWIG_As_int(obj1));
26684 if (SWIG_arg_fail(2)) SWIG_fail;
26685 }
26686 {
26687 arg3 = static_cast<int >(SWIG_As_int(obj2));
26688 if (SWIG_arg_fail(3)) SWIG_fail;
26689 }
26690 if (obj3) {
26691 {
26692 arg4 = static_cast<int >(SWIG_As_int(obj3));
26693 if (SWIG_arg_fail(4)) SWIG_fail;
26694 }
26695 }
26696 {
26697 PyThreadState* __tstate = wxPyBeginAllowThreads();
26698 (arg1)->Move(arg2,arg3,arg4);
26699
26700 wxPyEndAllowThreads(__tstate);
26701 if (PyErr_Occurred()) SWIG_fail;
26702 }
26703 Py_INCREF(Py_None); resultobj = Py_None;
26704 return resultobj;
26705 fail:
26706 return NULL;
26707 }
26708
26709
26710 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26711 PyObject *resultobj = NULL;
26712 wxWindow *arg1 = (wxWindow *) 0 ;
26713 wxSize const &arg2_defvalue = wxDefaultSize ;
26714 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
26715 wxSize temp2 ;
26716 PyObject * obj0 = 0 ;
26717 PyObject * obj1 = 0 ;
26718 char *kwnames[] = {
26719 (char *) "self",(char *) "size", NULL
26720 };
26721
26722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
26723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26724 if (SWIG_arg_fail(1)) SWIG_fail;
26725 if (obj1) {
26726 {
26727 arg2 = &temp2;
26728 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26729 }
26730 }
26731 {
26732 PyThreadState* __tstate = wxPyBeginAllowThreads();
26733 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
26734
26735 wxPyEndAllowThreads(__tstate);
26736 if (PyErr_Occurred()) SWIG_fail;
26737 }
26738 Py_INCREF(Py_None); resultobj = Py_None;
26739 return resultobj;
26740 fail:
26741 return NULL;
26742 }
26743
26744
26745 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26746 PyObject *resultobj = NULL;
26747 wxWindow *arg1 = (wxWindow *) 0 ;
26748 PyObject * obj0 = 0 ;
26749 char *kwnames[] = {
26750 (char *) "self", NULL
26751 };
26752
26753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26755 if (SWIG_arg_fail(1)) SWIG_fail;
26756 {
26757 PyThreadState* __tstate = wxPyBeginAllowThreads();
26758 (arg1)->Raise();
26759
26760 wxPyEndAllowThreads(__tstate);
26761 if (PyErr_Occurred()) SWIG_fail;
26762 }
26763 Py_INCREF(Py_None); resultobj = Py_None;
26764 return resultobj;
26765 fail:
26766 return NULL;
26767 }
26768
26769
26770 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26771 PyObject *resultobj = NULL;
26772 wxWindow *arg1 = (wxWindow *) 0 ;
26773 PyObject * obj0 = 0 ;
26774 char *kwnames[] = {
26775 (char *) "self", NULL
26776 };
26777
26778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26780 if (SWIG_arg_fail(1)) SWIG_fail;
26781 {
26782 PyThreadState* __tstate = wxPyBeginAllowThreads();
26783 (arg1)->Lower();
26784
26785 wxPyEndAllowThreads(__tstate);
26786 if (PyErr_Occurred()) SWIG_fail;
26787 }
26788 Py_INCREF(Py_None); resultobj = Py_None;
26789 return resultobj;
26790 fail:
26791 return NULL;
26792 }
26793
26794
26795 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26796 PyObject *resultobj = NULL;
26797 wxWindow *arg1 = (wxWindow *) 0 ;
26798 wxSize *arg2 = 0 ;
26799 wxSize temp2 ;
26800 PyObject * obj0 = 0 ;
26801 PyObject * obj1 = 0 ;
26802 char *kwnames[] = {
26803 (char *) "self",(char *) "size", NULL
26804 };
26805
26806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26808 if (SWIG_arg_fail(1)) SWIG_fail;
26809 {
26810 arg2 = &temp2;
26811 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26812 }
26813 {
26814 PyThreadState* __tstate = wxPyBeginAllowThreads();
26815 (arg1)->SetClientSize((wxSize const &)*arg2);
26816
26817 wxPyEndAllowThreads(__tstate);
26818 if (PyErr_Occurred()) SWIG_fail;
26819 }
26820 Py_INCREF(Py_None); resultobj = Py_None;
26821 return resultobj;
26822 fail:
26823 return NULL;
26824 }
26825
26826
26827 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26828 PyObject *resultobj = NULL;
26829 wxWindow *arg1 = (wxWindow *) 0 ;
26830 int arg2 ;
26831 int arg3 ;
26832 PyObject * obj0 = 0 ;
26833 PyObject * obj1 = 0 ;
26834 PyObject * obj2 = 0 ;
26835 char *kwnames[] = {
26836 (char *) "self",(char *) "width",(char *) "height", NULL
26837 };
26838
26839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26841 if (SWIG_arg_fail(1)) SWIG_fail;
26842 {
26843 arg2 = static_cast<int >(SWIG_As_int(obj1));
26844 if (SWIG_arg_fail(2)) SWIG_fail;
26845 }
26846 {
26847 arg3 = static_cast<int >(SWIG_As_int(obj2));
26848 if (SWIG_arg_fail(3)) SWIG_fail;
26849 }
26850 {
26851 PyThreadState* __tstate = wxPyBeginAllowThreads();
26852 (arg1)->SetClientSize(arg2,arg3);
26853
26854 wxPyEndAllowThreads(__tstate);
26855 if (PyErr_Occurred()) SWIG_fail;
26856 }
26857 Py_INCREF(Py_None); resultobj = Py_None;
26858 return resultobj;
26859 fail:
26860 return NULL;
26861 }
26862
26863
26864 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26865 PyObject *resultobj = NULL;
26866 wxWindow *arg1 = (wxWindow *) 0 ;
26867 wxRect *arg2 = 0 ;
26868 wxRect temp2 ;
26869 PyObject * obj0 = 0 ;
26870 PyObject * obj1 = 0 ;
26871 char *kwnames[] = {
26872 (char *) "self",(char *) "rect", NULL
26873 };
26874
26875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26877 if (SWIG_arg_fail(1)) SWIG_fail;
26878 {
26879 arg2 = &temp2;
26880 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26881 }
26882 {
26883 PyThreadState* __tstate = wxPyBeginAllowThreads();
26884 (arg1)->SetClientSize((wxRect const &)*arg2);
26885
26886 wxPyEndAllowThreads(__tstate);
26887 if (PyErr_Occurred()) SWIG_fail;
26888 }
26889 Py_INCREF(Py_None); resultobj = Py_None;
26890 return resultobj;
26891 fail:
26892 return NULL;
26893 }
26894
26895
26896 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26897 PyObject *resultobj = NULL;
26898 wxWindow *arg1 = (wxWindow *) 0 ;
26899 wxPoint result;
26900 PyObject * obj0 = 0 ;
26901 char *kwnames[] = {
26902 (char *) "self", NULL
26903 };
26904
26905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26907 if (SWIG_arg_fail(1)) SWIG_fail;
26908 {
26909 PyThreadState* __tstate = wxPyBeginAllowThreads();
26910 result = (arg1)->GetPosition();
26911
26912 wxPyEndAllowThreads(__tstate);
26913 if (PyErr_Occurred()) SWIG_fail;
26914 }
26915 {
26916 wxPoint * resultptr;
26917 resultptr = new wxPoint(static_cast<wxPoint & >(result));
26918 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26919 }
26920 return resultobj;
26921 fail:
26922 return NULL;
26923 }
26924
26925
26926 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26927 PyObject *resultobj = NULL;
26928 wxWindow *arg1 = (wxWindow *) 0 ;
26929 int *arg2 = (int *) 0 ;
26930 int *arg3 = (int *) 0 ;
26931 int temp2 ;
26932 int res2 = 0 ;
26933 int temp3 ;
26934 int res3 = 0 ;
26935 PyObject * obj0 = 0 ;
26936 char *kwnames[] = {
26937 (char *) "self", NULL
26938 };
26939
26940 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26941 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26944 if (SWIG_arg_fail(1)) SWIG_fail;
26945 {
26946 PyThreadState* __tstate = wxPyBeginAllowThreads();
26947 (arg1)->GetPosition(arg2,arg3);
26948
26949 wxPyEndAllowThreads(__tstate);
26950 if (PyErr_Occurred()) SWIG_fail;
26951 }
26952 Py_INCREF(Py_None); resultobj = Py_None;
26953 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26954 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26955 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26956 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26957 return resultobj;
26958 fail:
26959 return NULL;
26960 }
26961
26962
26963 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26964 PyObject *resultobj = NULL;
26965 wxWindow *arg1 = (wxWindow *) 0 ;
26966 wxSize result;
26967 PyObject * obj0 = 0 ;
26968 char *kwnames[] = {
26969 (char *) "self", NULL
26970 };
26971
26972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26974 if (SWIG_arg_fail(1)) SWIG_fail;
26975 {
26976 PyThreadState* __tstate = wxPyBeginAllowThreads();
26977 result = ((wxWindow const *)arg1)->GetSize();
26978
26979 wxPyEndAllowThreads(__tstate);
26980 if (PyErr_Occurred()) SWIG_fail;
26981 }
26982 {
26983 wxSize * resultptr;
26984 resultptr = new wxSize(static_cast<wxSize & >(result));
26985 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26986 }
26987 return resultobj;
26988 fail:
26989 return NULL;
26990 }
26991
26992
26993 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26994 PyObject *resultobj = NULL;
26995 wxWindow *arg1 = (wxWindow *) 0 ;
26996 int *arg2 = (int *) 0 ;
26997 int *arg3 = (int *) 0 ;
26998 int temp2 ;
26999 int res2 = 0 ;
27000 int temp3 ;
27001 int res3 = 0 ;
27002 PyObject * obj0 = 0 ;
27003 char *kwnames[] = {
27004 (char *) "self", NULL
27005 };
27006
27007 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27008 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
27010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27011 if (SWIG_arg_fail(1)) SWIG_fail;
27012 {
27013 PyThreadState* __tstate = wxPyBeginAllowThreads();
27014 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
27015
27016 wxPyEndAllowThreads(__tstate);
27017 if (PyErr_Occurred()) SWIG_fail;
27018 }
27019 Py_INCREF(Py_None); resultobj = Py_None;
27020 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27021 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27022 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27023 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27024 return resultobj;
27025 fail:
27026 return NULL;
27027 }
27028
27029
27030 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
27031 PyObject *resultobj = NULL;
27032 wxWindow *arg1 = (wxWindow *) 0 ;
27033 wxRect result;
27034 PyObject * obj0 = 0 ;
27035 char *kwnames[] = {
27036 (char *) "self", NULL
27037 };
27038
27039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
27040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27041 if (SWIG_arg_fail(1)) SWIG_fail;
27042 {
27043 PyThreadState* __tstate = wxPyBeginAllowThreads();
27044 result = ((wxWindow const *)arg1)->GetRect();
27045
27046 wxPyEndAllowThreads(__tstate);
27047 if (PyErr_Occurred()) SWIG_fail;
27048 }
27049 {
27050 wxRect * resultptr;
27051 resultptr = new wxRect(static_cast<wxRect & >(result));
27052 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
27053 }
27054 return resultobj;
27055 fail:
27056 return NULL;
27057 }
27058
27059
27060 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
27061 PyObject *resultobj = NULL;
27062 wxWindow *arg1 = (wxWindow *) 0 ;
27063 wxSize result;
27064 PyObject * obj0 = 0 ;
27065 char *kwnames[] = {
27066 (char *) "self", NULL
27067 };
27068
27069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
27070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27071 if (SWIG_arg_fail(1)) SWIG_fail;
27072 {
27073 PyThreadState* __tstate = wxPyBeginAllowThreads();
27074 result = ((wxWindow const *)arg1)->GetClientSize();
27075
27076 wxPyEndAllowThreads(__tstate);
27077 if (PyErr_Occurred()) SWIG_fail;
27078 }
27079 {
27080 wxSize * resultptr;
27081 resultptr = new wxSize(static_cast<wxSize & >(result));
27082 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27083 }
27084 return resultobj;
27085 fail:
27086 return NULL;
27087 }
27088
27089
27090 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27091 PyObject *resultobj = NULL;
27092 wxWindow *arg1 = (wxWindow *) 0 ;
27093 int *arg2 = (int *) 0 ;
27094 int *arg3 = (int *) 0 ;
27095 int temp2 ;
27096 int res2 = 0 ;
27097 int temp3 ;
27098 int res3 = 0 ;
27099 PyObject * obj0 = 0 ;
27100 char *kwnames[] = {
27101 (char *) "self", NULL
27102 };
27103
27104 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27105 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
27107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27108 if (SWIG_arg_fail(1)) SWIG_fail;
27109 {
27110 PyThreadState* __tstate = wxPyBeginAllowThreads();
27111 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
27112
27113 wxPyEndAllowThreads(__tstate);
27114 if (PyErr_Occurred()) SWIG_fail;
27115 }
27116 Py_INCREF(Py_None); resultobj = Py_None;
27117 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27118 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27119 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27120 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27121 return resultobj;
27122 fail:
27123 return NULL;
27124 }
27125
27126
27127 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
27128 PyObject *resultobj = NULL;
27129 wxWindow *arg1 = (wxWindow *) 0 ;
27130 wxPoint result;
27131 PyObject * obj0 = 0 ;
27132 char *kwnames[] = {
27133 (char *) "self", NULL
27134 };
27135
27136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
27137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27138 if (SWIG_arg_fail(1)) SWIG_fail;
27139 {
27140 PyThreadState* __tstate = wxPyBeginAllowThreads();
27141 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
27142
27143 wxPyEndAllowThreads(__tstate);
27144 if (PyErr_Occurred()) SWIG_fail;
27145 }
27146 {
27147 wxPoint * resultptr;
27148 resultptr = new wxPoint(static_cast<wxPoint & >(result));
27149 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
27150 }
27151 return resultobj;
27152 fail:
27153 return NULL;
27154 }
27155
27156
27157 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
27158 PyObject *resultobj = NULL;
27159 wxWindow *arg1 = (wxWindow *) 0 ;
27160 wxRect result;
27161 PyObject * obj0 = 0 ;
27162 char *kwnames[] = {
27163 (char *) "self", NULL
27164 };
27165
27166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
27167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27168 if (SWIG_arg_fail(1)) SWIG_fail;
27169 {
27170 PyThreadState* __tstate = wxPyBeginAllowThreads();
27171 result = ((wxWindow const *)arg1)->GetClientRect();
27172
27173 wxPyEndAllowThreads(__tstate);
27174 if (PyErr_Occurred()) SWIG_fail;
27175 }
27176 {
27177 wxRect * resultptr;
27178 resultptr = new wxRect(static_cast<wxRect & >(result));
27179 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
27180 }
27181 return resultobj;
27182 fail:
27183 return NULL;
27184 }
27185
27186
27187 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27188 PyObject *resultobj = NULL;
27189 wxWindow *arg1 = (wxWindow *) 0 ;
27190 wxSize result;
27191 PyObject * obj0 = 0 ;
27192 char *kwnames[] = {
27193 (char *) "self", NULL
27194 };
27195
27196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
27197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27198 if (SWIG_arg_fail(1)) SWIG_fail;
27199 {
27200 PyThreadState* __tstate = wxPyBeginAllowThreads();
27201 result = ((wxWindow const *)arg1)->GetBestSize();
27202
27203 wxPyEndAllowThreads(__tstate);
27204 if (PyErr_Occurred()) SWIG_fail;
27205 }
27206 {
27207 wxSize * resultptr;
27208 resultptr = new wxSize(static_cast<wxSize & >(result));
27209 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27210 }
27211 return resultobj;
27212 fail:
27213 return NULL;
27214 }
27215
27216
27217 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27218 PyObject *resultobj = NULL;
27219 wxWindow *arg1 = (wxWindow *) 0 ;
27220 int *arg2 = (int *) 0 ;
27221 int *arg3 = (int *) 0 ;
27222 int temp2 ;
27223 int res2 = 0 ;
27224 int temp3 ;
27225 int res3 = 0 ;
27226 PyObject * obj0 = 0 ;
27227 char *kwnames[] = {
27228 (char *) "self", NULL
27229 };
27230
27231 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27232 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
27234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27235 if (SWIG_arg_fail(1)) SWIG_fail;
27236 {
27237 PyThreadState* __tstate = wxPyBeginAllowThreads();
27238 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
27239
27240 wxPyEndAllowThreads(__tstate);
27241 if (PyErr_Occurred()) SWIG_fail;
27242 }
27243 Py_INCREF(Py_None); resultobj = Py_None;
27244 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27245 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27246 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27247 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27248 return resultobj;
27249 fail:
27250 return NULL;
27251 }
27252
27253
27254 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27255 PyObject *resultobj = NULL;
27256 wxWindow *arg1 = (wxWindow *) 0 ;
27257 PyObject * obj0 = 0 ;
27258 char *kwnames[] = {
27259 (char *) "self", NULL
27260 };
27261
27262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
27263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27264 if (SWIG_arg_fail(1)) SWIG_fail;
27265 {
27266 PyThreadState* __tstate = wxPyBeginAllowThreads();
27267 (arg1)->InvalidateBestSize();
27268
27269 wxPyEndAllowThreads(__tstate);
27270 if (PyErr_Occurred()) SWIG_fail;
27271 }
27272 Py_INCREF(Py_None); resultobj = Py_None;
27273 return resultobj;
27274 fail:
27275 return NULL;
27276 }
27277
27278
27279 static PyObject *_wrap_Window_CacheBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27280 PyObject *resultobj = NULL;
27281 wxWindow *arg1 = (wxWindow *) 0 ;
27282 wxSize *arg2 = 0 ;
27283 wxSize temp2 ;
27284 PyObject * obj0 = 0 ;
27285 PyObject * obj1 = 0 ;
27286 char *kwnames[] = {
27287 (char *) "self",(char *) "size", NULL
27288 };
27289
27290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) goto fail;
27291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27292 if (SWIG_arg_fail(1)) SWIG_fail;
27293 {
27294 arg2 = &temp2;
27295 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27296 }
27297 {
27298 PyThreadState* __tstate = wxPyBeginAllowThreads();
27299 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
27300
27301 wxPyEndAllowThreads(__tstate);
27302 if (PyErr_Occurred()) SWIG_fail;
27303 }
27304 Py_INCREF(Py_None); resultobj = Py_None;
27305 return resultobj;
27306 fail:
27307 return NULL;
27308 }
27309
27310
27311 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
27312 PyObject *resultobj = NULL;
27313 wxWindow *arg1 = (wxWindow *) 0 ;
27314 wxSize result;
27315 PyObject * obj0 = 0 ;
27316 char *kwnames[] = {
27317 (char *) "self", NULL
27318 };
27319
27320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
27321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27322 if (SWIG_arg_fail(1)) SWIG_fail;
27323 {
27324 PyThreadState* __tstate = wxPyBeginAllowThreads();
27325 result = ((wxWindow const *)arg1)->GetBestFittingSize();
27326
27327 wxPyEndAllowThreads(__tstate);
27328 if (PyErr_Occurred()) SWIG_fail;
27329 }
27330 {
27331 wxSize * resultptr;
27332 resultptr = new wxSize(static_cast<wxSize & >(result));
27333 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27334 }
27335 return resultobj;
27336 fail:
27337 return NULL;
27338 }
27339
27340
27341 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27342 PyObject *resultobj = NULL;
27343 wxWindow *arg1 = (wxWindow *) 0 ;
27344 wxSize result;
27345 PyObject * obj0 = 0 ;
27346 char *kwnames[] = {
27347 (char *) "self", NULL
27348 };
27349
27350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
27351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27352 if (SWIG_arg_fail(1)) SWIG_fail;
27353 {
27354 PyThreadState* __tstate = wxPyBeginAllowThreads();
27355 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
27356
27357 wxPyEndAllowThreads(__tstate);
27358 if (PyErr_Occurred()) SWIG_fail;
27359 }
27360 {
27361 wxSize * resultptr;
27362 resultptr = new wxSize(static_cast<wxSize & >(result));
27363 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27364 }
27365 return resultobj;
27366 fail:
27367 return NULL;
27368 }
27369
27370
27371 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
27372 PyObject *resultobj = NULL;
27373 wxWindow *arg1 = (wxWindow *) 0 ;
27374 int arg2 = (int) wxBOTH ;
27375 PyObject * obj0 = 0 ;
27376 PyObject * obj1 = 0 ;
27377 char *kwnames[] = {
27378 (char *) "self",(char *) "direction", NULL
27379 };
27380
27381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
27382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27383 if (SWIG_arg_fail(1)) SWIG_fail;
27384 if (obj1) {
27385 {
27386 arg2 = static_cast<int >(SWIG_As_int(obj1));
27387 if (SWIG_arg_fail(2)) SWIG_fail;
27388 }
27389 }
27390 {
27391 PyThreadState* __tstate = wxPyBeginAllowThreads();
27392 (arg1)->Center(arg2);
27393
27394 wxPyEndAllowThreads(__tstate);
27395 if (PyErr_Occurred()) SWIG_fail;
27396 }
27397 Py_INCREF(Py_None); resultobj = Py_None;
27398 return resultobj;
27399 fail:
27400 return NULL;
27401 }
27402
27403
27404 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
27405 PyObject *resultobj = NULL;
27406 wxWindow *arg1 = (wxWindow *) 0 ;
27407 int arg2 = (int) wxBOTH ;
27408 PyObject * obj0 = 0 ;
27409 PyObject * obj1 = 0 ;
27410 char *kwnames[] = {
27411 (char *) "self",(char *) "dir", NULL
27412 };
27413
27414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
27415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27416 if (SWIG_arg_fail(1)) SWIG_fail;
27417 if (obj1) {
27418 {
27419 arg2 = static_cast<int >(SWIG_As_int(obj1));
27420 if (SWIG_arg_fail(2)) SWIG_fail;
27421 }
27422 }
27423 {
27424 PyThreadState* __tstate = wxPyBeginAllowThreads();
27425 (arg1)->CenterOnScreen(arg2);
27426
27427 wxPyEndAllowThreads(__tstate);
27428 if (PyErr_Occurred()) SWIG_fail;
27429 }
27430 Py_INCREF(Py_None); resultobj = Py_None;
27431 return resultobj;
27432 fail:
27433 return NULL;
27434 }
27435
27436
27437 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
27438 PyObject *resultobj = NULL;
27439 wxWindow *arg1 = (wxWindow *) 0 ;
27440 int arg2 = (int) wxBOTH ;
27441 PyObject * obj0 = 0 ;
27442 PyObject * obj1 = 0 ;
27443 char *kwnames[] = {
27444 (char *) "self",(char *) "dir", NULL
27445 };
27446
27447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
27448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27449 if (SWIG_arg_fail(1)) SWIG_fail;
27450 if (obj1) {
27451 {
27452 arg2 = static_cast<int >(SWIG_As_int(obj1));
27453 if (SWIG_arg_fail(2)) SWIG_fail;
27454 }
27455 }
27456 {
27457 PyThreadState* __tstate = wxPyBeginAllowThreads();
27458 (arg1)->CenterOnParent(arg2);
27459
27460 wxPyEndAllowThreads(__tstate);
27461 if (PyErr_Occurred()) SWIG_fail;
27462 }
27463 Py_INCREF(Py_None); resultobj = Py_None;
27464 return resultobj;
27465 fail:
27466 return NULL;
27467 }
27468
27469
27470 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
27471 PyObject *resultobj = NULL;
27472 wxWindow *arg1 = (wxWindow *) 0 ;
27473 PyObject * obj0 = 0 ;
27474 char *kwnames[] = {
27475 (char *) "self", NULL
27476 };
27477
27478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
27479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27480 if (SWIG_arg_fail(1)) SWIG_fail;
27481 {
27482 PyThreadState* __tstate = wxPyBeginAllowThreads();
27483 (arg1)->Fit();
27484
27485 wxPyEndAllowThreads(__tstate);
27486 if (PyErr_Occurred()) SWIG_fail;
27487 }
27488 Py_INCREF(Py_None); resultobj = Py_None;
27489 return resultobj;
27490 fail:
27491 return NULL;
27492 }
27493
27494
27495 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
27496 PyObject *resultobj = NULL;
27497 wxWindow *arg1 = (wxWindow *) 0 ;
27498 PyObject * obj0 = 0 ;
27499 char *kwnames[] = {
27500 (char *) "self", NULL
27501 };
27502
27503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
27504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27505 if (SWIG_arg_fail(1)) SWIG_fail;
27506 {
27507 PyThreadState* __tstate = wxPyBeginAllowThreads();
27508 (arg1)->FitInside();
27509
27510 wxPyEndAllowThreads(__tstate);
27511 if (PyErr_Occurred()) SWIG_fail;
27512 }
27513 Py_INCREF(Py_None); resultobj = Py_None;
27514 return resultobj;
27515 fail:
27516 return NULL;
27517 }
27518
27519
27520 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27521 PyObject *resultobj = NULL;
27522 wxWindow *arg1 = (wxWindow *) 0 ;
27523 int arg2 ;
27524 int arg3 ;
27525 int arg4 = (int) -1 ;
27526 int arg5 = (int) -1 ;
27527 int arg6 = (int) -1 ;
27528 int arg7 = (int) -1 ;
27529 PyObject * obj0 = 0 ;
27530 PyObject * obj1 = 0 ;
27531 PyObject * obj2 = 0 ;
27532 PyObject * obj3 = 0 ;
27533 PyObject * obj4 = 0 ;
27534 PyObject * obj5 = 0 ;
27535 PyObject * obj6 = 0 ;
27536 char *kwnames[] = {
27537 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
27538 };
27539
27540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27542 if (SWIG_arg_fail(1)) SWIG_fail;
27543 {
27544 arg2 = static_cast<int >(SWIG_As_int(obj1));
27545 if (SWIG_arg_fail(2)) SWIG_fail;
27546 }
27547 {
27548 arg3 = static_cast<int >(SWIG_As_int(obj2));
27549 if (SWIG_arg_fail(3)) SWIG_fail;
27550 }
27551 if (obj3) {
27552 {
27553 arg4 = static_cast<int >(SWIG_As_int(obj3));
27554 if (SWIG_arg_fail(4)) SWIG_fail;
27555 }
27556 }
27557 if (obj4) {
27558 {
27559 arg5 = static_cast<int >(SWIG_As_int(obj4));
27560 if (SWIG_arg_fail(5)) SWIG_fail;
27561 }
27562 }
27563 if (obj5) {
27564 {
27565 arg6 = static_cast<int >(SWIG_As_int(obj5));
27566 if (SWIG_arg_fail(6)) SWIG_fail;
27567 }
27568 }
27569 if (obj6) {
27570 {
27571 arg7 = static_cast<int >(SWIG_As_int(obj6));
27572 if (SWIG_arg_fail(7)) SWIG_fail;
27573 }
27574 }
27575 {
27576 PyThreadState* __tstate = wxPyBeginAllowThreads();
27577 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
27578
27579 wxPyEndAllowThreads(__tstate);
27580 if (PyErr_Occurred()) SWIG_fail;
27581 }
27582 Py_INCREF(Py_None); resultobj = Py_None;
27583 return resultobj;
27584 fail:
27585 return NULL;
27586 }
27587
27588
27589 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27590 PyObject *resultobj = NULL;
27591 wxWindow *arg1 = (wxWindow *) 0 ;
27592 wxSize *arg2 = 0 ;
27593 wxSize const &arg3_defvalue = wxDefaultSize ;
27594 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27595 wxSize const &arg4_defvalue = wxDefaultSize ;
27596 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
27597 wxSize temp2 ;
27598 wxSize temp3 ;
27599 wxSize temp4 ;
27600 PyObject * obj0 = 0 ;
27601 PyObject * obj1 = 0 ;
27602 PyObject * obj2 = 0 ;
27603 PyObject * obj3 = 0 ;
27604 char *kwnames[] = {
27605 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
27606 };
27607
27608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
27609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27610 if (SWIG_arg_fail(1)) SWIG_fail;
27611 {
27612 arg2 = &temp2;
27613 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27614 }
27615 if (obj2) {
27616 {
27617 arg3 = &temp3;
27618 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27619 }
27620 }
27621 if (obj3) {
27622 {
27623 arg4 = &temp4;
27624 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
27625 }
27626 }
27627 {
27628 PyThreadState* __tstate = wxPyBeginAllowThreads();
27629 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
27630
27631 wxPyEndAllowThreads(__tstate);
27632 if (PyErr_Occurred()) SWIG_fail;
27633 }
27634 Py_INCREF(Py_None); resultobj = Py_None;
27635 return resultobj;
27636 fail:
27637 return NULL;
27638 }
27639
27640
27641 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27642 PyObject *resultobj = NULL;
27643 wxWindow *arg1 = (wxWindow *) 0 ;
27644 int arg2 ;
27645 int arg3 ;
27646 int arg4 = (int) -1 ;
27647 int arg5 = (int) -1 ;
27648 PyObject * obj0 = 0 ;
27649 PyObject * obj1 = 0 ;
27650 PyObject * obj2 = 0 ;
27651 PyObject * obj3 = 0 ;
27652 PyObject * obj4 = 0 ;
27653 char *kwnames[] = {
27654 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
27655 };
27656
27657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
27658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27659 if (SWIG_arg_fail(1)) SWIG_fail;
27660 {
27661 arg2 = static_cast<int >(SWIG_As_int(obj1));
27662 if (SWIG_arg_fail(2)) SWIG_fail;
27663 }
27664 {
27665 arg3 = static_cast<int >(SWIG_As_int(obj2));
27666 if (SWIG_arg_fail(3)) SWIG_fail;
27667 }
27668 if (obj3) {
27669 {
27670 arg4 = static_cast<int >(SWIG_As_int(obj3));
27671 if (SWIG_arg_fail(4)) SWIG_fail;
27672 }
27673 }
27674 if (obj4) {
27675 {
27676 arg5 = static_cast<int >(SWIG_As_int(obj4));
27677 if (SWIG_arg_fail(5)) SWIG_fail;
27678 }
27679 }
27680 {
27681 PyThreadState* __tstate = wxPyBeginAllowThreads();
27682 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
27683
27684 wxPyEndAllowThreads(__tstate);
27685 if (PyErr_Occurred()) SWIG_fail;
27686 }
27687 Py_INCREF(Py_None); resultobj = Py_None;
27688 return resultobj;
27689 fail:
27690 return NULL;
27691 }
27692
27693
27694 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27695 PyObject *resultobj = NULL;
27696 wxWindow *arg1 = (wxWindow *) 0 ;
27697 wxSize *arg2 = 0 ;
27698 wxSize const &arg3_defvalue = wxDefaultSize ;
27699 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27700 wxSize temp2 ;
27701 wxSize temp3 ;
27702 PyObject * obj0 = 0 ;
27703 PyObject * obj1 = 0 ;
27704 PyObject * obj2 = 0 ;
27705 char *kwnames[] = {
27706 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
27707 };
27708
27709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
27710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27711 if (SWIG_arg_fail(1)) SWIG_fail;
27712 {
27713 arg2 = &temp2;
27714 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27715 }
27716 if (obj2) {
27717 {
27718 arg3 = &temp3;
27719 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27720 }
27721 }
27722 {
27723 PyThreadState* __tstate = wxPyBeginAllowThreads();
27724 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
27725
27726 wxPyEndAllowThreads(__tstate);
27727 if (PyErr_Occurred()) SWIG_fail;
27728 }
27729 Py_INCREF(Py_None); resultobj = Py_None;
27730 return resultobj;
27731 fail:
27732 return NULL;
27733 }
27734
27735
27736 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27737 PyObject *resultobj = NULL;
27738 wxWindow *arg1 = (wxWindow *) 0 ;
27739 wxSize result;
27740 PyObject * obj0 = 0 ;
27741 char *kwnames[] = {
27742 (char *) "self", NULL
27743 };
27744
27745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
27746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27747 if (SWIG_arg_fail(1)) SWIG_fail;
27748 {
27749 PyThreadState* __tstate = wxPyBeginAllowThreads();
27750 result = ((wxWindow const *)arg1)->GetMaxSize();
27751
27752 wxPyEndAllowThreads(__tstate);
27753 if (PyErr_Occurred()) SWIG_fail;
27754 }
27755 {
27756 wxSize * resultptr;
27757 resultptr = new wxSize(static_cast<wxSize & >(result));
27758 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27759 }
27760 return resultobj;
27761 fail:
27762 return NULL;
27763 }
27764
27765
27766 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27767 PyObject *resultobj = NULL;
27768 wxWindow *arg1 = (wxWindow *) 0 ;
27769 wxSize result;
27770 PyObject * obj0 = 0 ;
27771 char *kwnames[] = {
27772 (char *) "self", NULL
27773 };
27774
27775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27777 if (SWIG_arg_fail(1)) SWIG_fail;
27778 {
27779 PyThreadState* __tstate = wxPyBeginAllowThreads();
27780 result = ((wxWindow const *)arg1)->GetMinSize();
27781
27782 wxPyEndAllowThreads(__tstate);
27783 if (PyErr_Occurred()) SWIG_fail;
27784 }
27785 {
27786 wxSize * resultptr;
27787 resultptr = new wxSize(static_cast<wxSize & >(result));
27788 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27789 }
27790 return resultobj;
27791 fail:
27792 return NULL;
27793 }
27794
27795
27796 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27797 PyObject *resultobj = NULL;
27798 wxWindow *arg1 = (wxWindow *) 0 ;
27799 wxSize *arg2 = 0 ;
27800 wxSize temp2 ;
27801 PyObject * obj0 = 0 ;
27802 PyObject * obj1 = 0 ;
27803 char *kwnames[] = {
27804 (char *) "self",(char *) "minSize", NULL
27805 };
27806
27807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27809 if (SWIG_arg_fail(1)) SWIG_fail;
27810 {
27811 arg2 = &temp2;
27812 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27813 }
27814 {
27815 PyThreadState* __tstate = wxPyBeginAllowThreads();
27816 (arg1)->SetMinSize((wxSize const &)*arg2);
27817
27818 wxPyEndAllowThreads(__tstate);
27819 if (PyErr_Occurred()) SWIG_fail;
27820 }
27821 Py_INCREF(Py_None); resultobj = Py_None;
27822 return resultobj;
27823 fail:
27824 return NULL;
27825 }
27826
27827
27828 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27829 PyObject *resultobj = NULL;
27830 wxWindow *arg1 = (wxWindow *) 0 ;
27831 wxSize *arg2 = 0 ;
27832 wxSize temp2 ;
27833 PyObject * obj0 = 0 ;
27834 PyObject * obj1 = 0 ;
27835 char *kwnames[] = {
27836 (char *) "self",(char *) "maxSize", NULL
27837 };
27838
27839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27841 if (SWIG_arg_fail(1)) SWIG_fail;
27842 {
27843 arg2 = &temp2;
27844 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27845 }
27846 {
27847 PyThreadState* __tstate = wxPyBeginAllowThreads();
27848 (arg1)->SetMaxSize((wxSize const &)*arg2);
27849
27850 wxPyEndAllowThreads(__tstate);
27851 if (PyErr_Occurred()) SWIG_fail;
27852 }
27853 Py_INCREF(Py_None); resultobj = Py_None;
27854 return resultobj;
27855 fail:
27856 return NULL;
27857 }
27858
27859
27860 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27861 PyObject *resultobj = NULL;
27862 wxWindow *arg1 = (wxWindow *) 0 ;
27863 int result;
27864 PyObject * obj0 = 0 ;
27865 char *kwnames[] = {
27866 (char *) "self", NULL
27867 };
27868
27869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27871 if (SWIG_arg_fail(1)) SWIG_fail;
27872 {
27873 PyThreadState* __tstate = wxPyBeginAllowThreads();
27874 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27875
27876 wxPyEndAllowThreads(__tstate);
27877 if (PyErr_Occurred()) SWIG_fail;
27878 }
27879 {
27880 resultobj = SWIG_From_int(static_cast<int >(result));
27881 }
27882 return resultobj;
27883 fail:
27884 return NULL;
27885 }
27886
27887
27888 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27889 PyObject *resultobj = NULL;
27890 wxWindow *arg1 = (wxWindow *) 0 ;
27891 int result;
27892 PyObject * obj0 = 0 ;
27893 char *kwnames[] = {
27894 (char *) "self", NULL
27895 };
27896
27897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27899 if (SWIG_arg_fail(1)) SWIG_fail;
27900 {
27901 PyThreadState* __tstate = wxPyBeginAllowThreads();
27902 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27903
27904 wxPyEndAllowThreads(__tstate);
27905 if (PyErr_Occurred()) SWIG_fail;
27906 }
27907 {
27908 resultobj = SWIG_From_int(static_cast<int >(result));
27909 }
27910 return resultobj;
27911 fail:
27912 return NULL;
27913 }
27914
27915
27916 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27917 PyObject *resultobj = NULL;
27918 wxWindow *arg1 = (wxWindow *) 0 ;
27919 int result;
27920 PyObject * obj0 = 0 ;
27921 char *kwnames[] = {
27922 (char *) "self", NULL
27923 };
27924
27925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27927 if (SWIG_arg_fail(1)) SWIG_fail;
27928 {
27929 PyThreadState* __tstate = wxPyBeginAllowThreads();
27930 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27931
27932 wxPyEndAllowThreads(__tstate);
27933 if (PyErr_Occurred()) SWIG_fail;
27934 }
27935 {
27936 resultobj = SWIG_From_int(static_cast<int >(result));
27937 }
27938 return resultobj;
27939 fail:
27940 return NULL;
27941 }
27942
27943
27944 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27945 PyObject *resultobj = NULL;
27946 wxWindow *arg1 = (wxWindow *) 0 ;
27947 int result;
27948 PyObject * obj0 = 0 ;
27949 char *kwnames[] = {
27950 (char *) "self", NULL
27951 };
27952
27953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27955 if (SWIG_arg_fail(1)) SWIG_fail;
27956 {
27957 PyThreadState* __tstate = wxPyBeginAllowThreads();
27958 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27959
27960 wxPyEndAllowThreads(__tstate);
27961 if (PyErr_Occurred()) SWIG_fail;
27962 }
27963 {
27964 resultobj = SWIG_From_int(static_cast<int >(result));
27965 }
27966 return resultobj;
27967 fail:
27968 return NULL;
27969 }
27970
27971
27972 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27973 PyObject *resultobj = NULL;
27974 wxWindow *arg1 = (wxWindow *) 0 ;
27975 wxSize *arg2 = 0 ;
27976 wxSize temp2 ;
27977 PyObject * obj0 = 0 ;
27978 PyObject * obj1 = 0 ;
27979 char *kwnames[] = {
27980 (char *) "self",(char *) "size", NULL
27981 };
27982
27983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27985 if (SWIG_arg_fail(1)) SWIG_fail;
27986 {
27987 arg2 = &temp2;
27988 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27989 }
27990 {
27991 PyThreadState* __tstate = wxPyBeginAllowThreads();
27992 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27993
27994 wxPyEndAllowThreads(__tstate);
27995 if (PyErr_Occurred()) SWIG_fail;
27996 }
27997 Py_INCREF(Py_None); resultobj = Py_None;
27998 return resultobj;
27999 fail:
28000 return NULL;
28001 }
28002
28003
28004 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
28005 PyObject *resultobj = NULL;
28006 wxWindow *arg1 = (wxWindow *) 0 ;
28007 int arg2 ;
28008 int arg3 ;
28009 PyObject * obj0 = 0 ;
28010 PyObject * obj1 = 0 ;
28011 PyObject * obj2 = 0 ;
28012 char *kwnames[] = {
28013 (char *) "self",(char *) "w",(char *) "h", NULL
28014 };
28015
28016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
28017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28018 if (SWIG_arg_fail(1)) SWIG_fail;
28019 {
28020 arg2 = static_cast<int >(SWIG_As_int(obj1));
28021 if (SWIG_arg_fail(2)) SWIG_fail;
28022 }
28023 {
28024 arg3 = static_cast<int >(SWIG_As_int(obj2));
28025 if (SWIG_arg_fail(3)) SWIG_fail;
28026 }
28027 {
28028 PyThreadState* __tstate = wxPyBeginAllowThreads();
28029 (arg1)->SetVirtualSize(arg2,arg3);
28030
28031 wxPyEndAllowThreads(__tstate);
28032 if (PyErr_Occurred()) SWIG_fail;
28033 }
28034 Py_INCREF(Py_None); resultobj = Py_None;
28035 return resultobj;
28036 fail:
28037 return NULL;
28038 }
28039
28040
28041 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28042 PyObject *resultobj = NULL;
28043 wxWindow *arg1 = (wxWindow *) 0 ;
28044 wxSize result;
28045 PyObject * obj0 = 0 ;
28046 char *kwnames[] = {
28047 (char *) "self", NULL
28048 };
28049
28050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
28051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28052 if (SWIG_arg_fail(1)) SWIG_fail;
28053 {
28054 PyThreadState* __tstate = wxPyBeginAllowThreads();
28055 result = ((wxWindow const *)arg1)->GetVirtualSize();
28056
28057 wxPyEndAllowThreads(__tstate);
28058 if (PyErr_Occurred()) SWIG_fail;
28059 }
28060 {
28061 wxSize * resultptr;
28062 resultptr = new wxSize(static_cast<wxSize & >(result));
28063 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28064 }
28065 return resultobj;
28066 fail:
28067 return NULL;
28068 }
28069
28070
28071 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
28072 PyObject *resultobj = NULL;
28073 wxWindow *arg1 = (wxWindow *) 0 ;
28074 int *arg2 = (int *) 0 ;
28075 int *arg3 = (int *) 0 ;
28076 int temp2 ;
28077 int res2 = 0 ;
28078 int temp3 ;
28079 int res3 = 0 ;
28080 PyObject * obj0 = 0 ;
28081 char *kwnames[] = {
28082 (char *) "self", NULL
28083 };
28084
28085 arg2 = &temp2; res2 = SWIG_NEWOBJ;
28086 arg3 = &temp3; res3 = SWIG_NEWOBJ;
28087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
28088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28089 if (SWIG_arg_fail(1)) SWIG_fail;
28090 {
28091 PyThreadState* __tstate = wxPyBeginAllowThreads();
28092 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
28093
28094 wxPyEndAllowThreads(__tstate);
28095 if (PyErr_Occurred()) SWIG_fail;
28096 }
28097 Py_INCREF(Py_None); resultobj = Py_None;
28098 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
28099 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
28100 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
28101 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
28102 return resultobj;
28103 fail:
28104 return NULL;
28105 }
28106
28107
28108 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
28109 PyObject *resultobj = NULL;
28110 wxWindow *arg1 = (wxWindow *) 0 ;
28111 wxSize result;
28112 PyObject * obj0 = 0 ;
28113 char *kwnames[] = {
28114 (char *) "self", NULL
28115 };
28116
28117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
28118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28119 if (SWIG_arg_fail(1)) SWIG_fail;
28120 {
28121 PyThreadState* __tstate = wxPyBeginAllowThreads();
28122 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
28123
28124 wxPyEndAllowThreads(__tstate);
28125 if (PyErr_Occurred()) SWIG_fail;
28126 }
28127 {
28128 wxSize * resultptr;
28129 resultptr = new wxSize(static_cast<wxSize & >(result));
28130 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28131 }
28132 return resultobj;
28133 fail:
28134 return NULL;
28135 }
28136
28137
28138 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
28139 PyObject *resultobj = NULL;
28140 wxWindow *arg1 = (wxWindow *) 0 ;
28141 bool arg2 = (bool) true ;
28142 bool result;
28143 PyObject * obj0 = 0 ;
28144 PyObject * obj1 = 0 ;
28145 char *kwnames[] = {
28146 (char *) "self",(char *) "show", NULL
28147 };
28148
28149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
28150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28151 if (SWIG_arg_fail(1)) SWIG_fail;
28152 if (obj1) {
28153 {
28154 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28155 if (SWIG_arg_fail(2)) SWIG_fail;
28156 }
28157 }
28158 {
28159 PyThreadState* __tstate = wxPyBeginAllowThreads();
28160 result = (bool)(arg1)->Show(arg2);
28161
28162 wxPyEndAllowThreads(__tstate);
28163 if (PyErr_Occurred()) SWIG_fail;
28164 }
28165 {
28166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28167 }
28168 return resultobj;
28169 fail:
28170 return NULL;
28171 }
28172
28173
28174 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
28175 PyObject *resultobj = NULL;
28176 wxWindow *arg1 = (wxWindow *) 0 ;
28177 bool result;
28178 PyObject * obj0 = 0 ;
28179 char *kwnames[] = {
28180 (char *) "self", NULL
28181 };
28182
28183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
28184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28185 if (SWIG_arg_fail(1)) SWIG_fail;
28186 {
28187 PyThreadState* __tstate = wxPyBeginAllowThreads();
28188 result = (bool)(arg1)->Hide();
28189
28190 wxPyEndAllowThreads(__tstate);
28191 if (PyErr_Occurred()) SWIG_fail;
28192 }
28193 {
28194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28195 }
28196 return resultobj;
28197 fail:
28198 return NULL;
28199 }
28200
28201
28202 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
28203 PyObject *resultobj = NULL;
28204 wxWindow *arg1 = (wxWindow *) 0 ;
28205 bool arg2 = (bool) true ;
28206 bool result;
28207 PyObject * obj0 = 0 ;
28208 PyObject * obj1 = 0 ;
28209 char *kwnames[] = {
28210 (char *) "self",(char *) "enable", NULL
28211 };
28212
28213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
28214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28215 if (SWIG_arg_fail(1)) SWIG_fail;
28216 if (obj1) {
28217 {
28218 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28219 if (SWIG_arg_fail(2)) SWIG_fail;
28220 }
28221 }
28222 {
28223 PyThreadState* __tstate = wxPyBeginAllowThreads();
28224 result = (bool)(arg1)->Enable(arg2);
28225
28226 wxPyEndAllowThreads(__tstate);
28227 if (PyErr_Occurred()) SWIG_fail;
28228 }
28229 {
28230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28231 }
28232 return resultobj;
28233 fail:
28234 return NULL;
28235 }
28236
28237
28238 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
28239 PyObject *resultobj = NULL;
28240 wxWindow *arg1 = (wxWindow *) 0 ;
28241 bool result;
28242 PyObject * obj0 = 0 ;
28243 char *kwnames[] = {
28244 (char *) "self", NULL
28245 };
28246
28247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
28248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28249 if (SWIG_arg_fail(1)) SWIG_fail;
28250 {
28251 PyThreadState* __tstate = wxPyBeginAllowThreads();
28252 result = (bool)(arg1)->Disable();
28253
28254 wxPyEndAllowThreads(__tstate);
28255 if (PyErr_Occurred()) SWIG_fail;
28256 }
28257 {
28258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28259 }
28260 return resultobj;
28261 fail:
28262 return NULL;
28263 }
28264
28265
28266 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
28267 PyObject *resultobj = NULL;
28268 wxWindow *arg1 = (wxWindow *) 0 ;
28269 bool result;
28270 PyObject * obj0 = 0 ;
28271 char *kwnames[] = {
28272 (char *) "self", NULL
28273 };
28274
28275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
28276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28277 if (SWIG_arg_fail(1)) SWIG_fail;
28278 {
28279 PyThreadState* __tstate = wxPyBeginAllowThreads();
28280 result = (bool)((wxWindow const *)arg1)->IsShown();
28281
28282 wxPyEndAllowThreads(__tstate);
28283 if (PyErr_Occurred()) SWIG_fail;
28284 }
28285 {
28286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28287 }
28288 return resultobj;
28289 fail:
28290 return NULL;
28291 }
28292
28293
28294 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28295 PyObject *resultobj = NULL;
28296 wxWindow *arg1 = (wxWindow *) 0 ;
28297 bool result;
28298 PyObject * obj0 = 0 ;
28299 char *kwnames[] = {
28300 (char *) "self", NULL
28301 };
28302
28303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
28304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28305 if (SWIG_arg_fail(1)) SWIG_fail;
28306 {
28307 PyThreadState* __tstate = wxPyBeginAllowThreads();
28308 result = (bool)((wxWindow const *)arg1)->IsEnabled();
28309
28310 wxPyEndAllowThreads(__tstate);
28311 if (PyErr_Occurred()) SWIG_fail;
28312 }
28313 {
28314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28315 }
28316 return resultobj;
28317 fail:
28318 return NULL;
28319 }
28320
28321
28322 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28323 PyObject *resultobj = NULL;
28324 wxWindow *arg1 = (wxWindow *) 0 ;
28325 long arg2 ;
28326 PyObject * obj0 = 0 ;
28327 PyObject * obj1 = 0 ;
28328 char *kwnames[] = {
28329 (char *) "self",(char *) "style", NULL
28330 };
28331
28332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
28333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28334 if (SWIG_arg_fail(1)) SWIG_fail;
28335 {
28336 arg2 = static_cast<long >(SWIG_As_long(obj1));
28337 if (SWIG_arg_fail(2)) SWIG_fail;
28338 }
28339 {
28340 PyThreadState* __tstate = wxPyBeginAllowThreads();
28341 (arg1)->SetWindowStyleFlag(arg2);
28342
28343 wxPyEndAllowThreads(__tstate);
28344 if (PyErr_Occurred()) SWIG_fail;
28345 }
28346 Py_INCREF(Py_None); resultobj = Py_None;
28347 return resultobj;
28348 fail:
28349 return NULL;
28350 }
28351
28352
28353 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28354 PyObject *resultobj = NULL;
28355 wxWindow *arg1 = (wxWindow *) 0 ;
28356 long result;
28357 PyObject * obj0 = 0 ;
28358 char *kwnames[] = {
28359 (char *) "self", NULL
28360 };
28361
28362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
28363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28364 if (SWIG_arg_fail(1)) SWIG_fail;
28365 {
28366 PyThreadState* __tstate = wxPyBeginAllowThreads();
28367 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
28368
28369 wxPyEndAllowThreads(__tstate);
28370 if (PyErr_Occurred()) SWIG_fail;
28371 }
28372 {
28373 resultobj = SWIG_From_long(static_cast<long >(result));
28374 }
28375 return resultobj;
28376 fail:
28377 return NULL;
28378 }
28379
28380
28381 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28382 PyObject *resultobj = NULL;
28383 wxWindow *arg1 = (wxWindow *) 0 ;
28384 int arg2 ;
28385 bool result;
28386 PyObject * obj0 = 0 ;
28387 PyObject * obj1 = 0 ;
28388 char *kwnames[] = {
28389 (char *) "self",(char *) "flag", NULL
28390 };
28391
28392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
28393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28394 if (SWIG_arg_fail(1)) SWIG_fail;
28395 {
28396 arg2 = static_cast<int >(SWIG_As_int(obj1));
28397 if (SWIG_arg_fail(2)) SWIG_fail;
28398 }
28399 {
28400 PyThreadState* __tstate = wxPyBeginAllowThreads();
28401 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
28402
28403 wxPyEndAllowThreads(__tstate);
28404 if (PyErr_Occurred()) SWIG_fail;
28405 }
28406 {
28407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28408 }
28409 return resultobj;
28410 fail:
28411 return NULL;
28412 }
28413
28414
28415 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
28416 PyObject *resultobj = NULL;
28417 wxWindow *arg1 = (wxWindow *) 0 ;
28418 bool result;
28419 PyObject * obj0 = 0 ;
28420 char *kwnames[] = {
28421 (char *) "self", NULL
28422 };
28423
28424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
28425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28426 if (SWIG_arg_fail(1)) SWIG_fail;
28427 {
28428 PyThreadState* __tstate = wxPyBeginAllowThreads();
28429 result = (bool)((wxWindow const *)arg1)->IsRetained();
28430
28431 wxPyEndAllowThreads(__tstate);
28432 if (PyErr_Occurred()) SWIG_fail;
28433 }
28434 {
28435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28436 }
28437 return resultobj;
28438 fail:
28439 return NULL;
28440 }
28441
28442
28443 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28444 PyObject *resultobj = NULL;
28445 wxWindow *arg1 = (wxWindow *) 0 ;
28446 long arg2 ;
28447 PyObject * obj0 = 0 ;
28448 PyObject * obj1 = 0 ;
28449 char *kwnames[] = {
28450 (char *) "self",(char *) "exStyle", NULL
28451 };
28452
28453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
28454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28455 if (SWIG_arg_fail(1)) SWIG_fail;
28456 {
28457 arg2 = static_cast<long >(SWIG_As_long(obj1));
28458 if (SWIG_arg_fail(2)) SWIG_fail;
28459 }
28460 {
28461 PyThreadState* __tstate = wxPyBeginAllowThreads();
28462 (arg1)->SetExtraStyle(arg2);
28463
28464 wxPyEndAllowThreads(__tstate);
28465 if (PyErr_Occurred()) SWIG_fail;
28466 }
28467 Py_INCREF(Py_None); resultobj = Py_None;
28468 return resultobj;
28469 fail:
28470 return NULL;
28471 }
28472
28473
28474 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28475 PyObject *resultobj = NULL;
28476 wxWindow *arg1 = (wxWindow *) 0 ;
28477 long result;
28478 PyObject * obj0 = 0 ;
28479 char *kwnames[] = {
28480 (char *) "self", NULL
28481 };
28482
28483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
28484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28485 if (SWIG_arg_fail(1)) SWIG_fail;
28486 {
28487 PyThreadState* __tstate = wxPyBeginAllowThreads();
28488 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
28489
28490 wxPyEndAllowThreads(__tstate);
28491 if (PyErr_Occurred()) SWIG_fail;
28492 }
28493 {
28494 resultobj = SWIG_From_long(static_cast<long >(result));
28495 }
28496 return resultobj;
28497 fail:
28498 return NULL;
28499 }
28500
28501
28502 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
28503 PyObject *resultobj = NULL;
28504 wxWindow *arg1 = (wxWindow *) 0 ;
28505 bool arg2 = (bool) true ;
28506 PyObject * obj0 = 0 ;
28507 PyObject * obj1 = 0 ;
28508 char *kwnames[] = {
28509 (char *) "self",(char *) "modal", NULL
28510 };
28511
28512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
28513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28514 if (SWIG_arg_fail(1)) SWIG_fail;
28515 if (obj1) {
28516 {
28517 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28518 if (SWIG_arg_fail(2)) SWIG_fail;
28519 }
28520 }
28521 {
28522 PyThreadState* __tstate = wxPyBeginAllowThreads();
28523 (arg1)->MakeModal(arg2);
28524
28525 wxPyEndAllowThreads(__tstate);
28526 if (PyErr_Occurred()) SWIG_fail;
28527 }
28528 Py_INCREF(Py_None); resultobj = Py_None;
28529 return resultobj;
28530 fail:
28531 return NULL;
28532 }
28533
28534
28535 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28536 PyObject *resultobj = NULL;
28537 wxWindow *arg1 = (wxWindow *) 0 ;
28538 bool arg2 ;
28539 PyObject * obj0 = 0 ;
28540 PyObject * obj1 = 0 ;
28541 char *kwnames[] = {
28542 (char *) "self",(char *) "enableTheme", NULL
28543 };
28544
28545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
28546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28547 if (SWIG_arg_fail(1)) SWIG_fail;
28548 {
28549 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
28550 if (SWIG_arg_fail(2)) SWIG_fail;
28551 }
28552 {
28553 PyThreadState* __tstate = wxPyBeginAllowThreads();
28554 (arg1)->SetThemeEnabled(arg2);
28555
28556 wxPyEndAllowThreads(__tstate);
28557 if (PyErr_Occurred()) SWIG_fail;
28558 }
28559 Py_INCREF(Py_None); resultobj = Py_None;
28560 return resultobj;
28561 fail:
28562 return NULL;
28563 }
28564
28565
28566 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28567 PyObject *resultobj = NULL;
28568 wxWindow *arg1 = (wxWindow *) 0 ;
28569 bool result;
28570 PyObject * obj0 = 0 ;
28571 char *kwnames[] = {
28572 (char *) "self", NULL
28573 };
28574
28575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
28576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28577 if (SWIG_arg_fail(1)) SWIG_fail;
28578 {
28579 PyThreadState* __tstate = wxPyBeginAllowThreads();
28580 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
28581
28582 wxPyEndAllowThreads(__tstate);
28583 if (PyErr_Occurred()) SWIG_fail;
28584 }
28585 {
28586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28587 }
28588 return resultobj;
28589 fail:
28590 return NULL;
28591 }
28592
28593
28594 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28595 PyObject *resultobj = NULL;
28596 wxWindow *arg1 = (wxWindow *) 0 ;
28597 PyObject * obj0 = 0 ;
28598 char *kwnames[] = {
28599 (char *) "self", NULL
28600 };
28601
28602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
28603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28604 if (SWIG_arg_fail(1)) SWIG_fail;
28605 {
28606 PyThreadState* __tstate = wxPyBeginAllowThreads();
28607 (arg1)->SetFocus();
28608
28609 wxPyEndAllowThreads(__tstate);
28610 if (PyErr_Occurred()) SWIG_fail;
28611 }
28612 Py_INCREF(Py_None); resultobj = Py_None;
28613 return resultobj;
28614 fail:
28615 return NULL;
28616 }
28617
28618
28619 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
28620 PyObject *resultobj = NULL;
28621 wxWindow *arg1 = (wxWindow *) 0 ;
28622 PyObject * obj0 = 0 ;
28623 char *kwnames[] = {
28624 (char *) "self", NULL
28625 };
28626
28627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
28628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28629 if (SWIG_arg_fail(1)) SWIG_fail;
28630 {
28631 PyThreadState* __tstate = wxPyBeginAllowThreads();
28632 (arg1)->SetFocusFromKbd();
28633
28634 wxPyEndAllowThreads(__tstate);
28635 if (PyErr_Occurred()) SWIG_fail;
28636 }
28637 Py_INCREF(Py_None); resultobj = Py_None;
28638 return resultobj;
28639 fail:
28640 return NULL;
28641 }
28642
28643
28644 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28645 PyObject *resultobj = NULL;
28646 wxWindow *result;
28647 char *kwnames[] = {
28648 NULL
28649 };
28650
28651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
28652 {
28653 if (!wxPyCheckForApp()) SWIG_fail;
28654 PyThreadState* __tstate = wxPyBeginAllowThreads();
28655 result = (wxWindow *)wxWindow::FindFocus();
28656
28657 wxPyEndAllowThreads(__tstate);
28658 if (PyErr_Occurred()) SWIG_fail;
28659 }
28660 {
28661 resultobj = wxPyMake_wxObject(result, 0);
28662 }
28663 return resultobj;
28664 fail:
28665 return NULL;
28666 }
28667
28668
28669 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28670 PyObject *resultobj = NULL;
28671 wxWindow *arg1 = (wxWindow *) 0 ;
28672 bool result;
28673 PyObject * obj0 = 0 ;
28674 char *kwnames[] = {
28675 (char *) "self", NULL
28676 };
28677
28678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
28679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28680 if (SWIG_arg_fail(1)) SWIG_fail;
28681 {
28682 PyThreadState* __tstate = wxPyBeginAllowThreads();
28683 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
28684
28685 wxPyEndAllowThreads(__tstate);
28686 if (PyErr_Occurred()) SWIG_fail;
28687 }
28688 {
28689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28690 }
28691 return resultobj;
28692 fail:
28693 return NULL;
28694 }
28695
28696
28697 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
28698 PyObject *resultobj = NULL;
28699 wxWindow *arg1 = (wxWindow *) 0 ;
28700 bool result;
28701 PyObject * obj0 = 0 ;
28702 char *kwnames[] = {
28703 (char *) "self", NULL
28704 };
28705
28706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
28707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28708 if (SWIG_arg_fail(1)) SWIG_fail;
28709 {
28710 PyThreadState* __tstate = wxPyBeginAllowThreads();
28711 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
28712
28713 wxPyEndAllowThreads(__tstate);
28714 if (PyErr_Occurred()) SWIG_fail;
28715 }
28716 {
28717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28718 }
28719 return resultobj;
28720 fail:
28721 return NULL;
28722 }
28723
28724
28725 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28726 PyObject *resultobj = NULL;
28727 wxWindow *arg1 = (wxWindow *) 0 ;
28728 wxWindow *result;
28729 PyObject * obj0 = 0 ;
28730 char *kwnames[] = {
28731 (char *) "self", NULL
28732 };
28733
28734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
28735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28736 if (SWIG_arg_fail(1)) SWIG_fail;
28737 {
28738 PyThreadState* __tstate = wxPyBeginAllowThreads();
28739 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
28740
28741 wxPyEndAllowThreads(__tstate);
28742 if (PyErr_Occurred()) SWIG_fail;
28743 }
28744 {
28745 resultobj = wxPyMake_wxObject(result, 0);
28746 }
28747 return resultobj;
28748 fail:
28749 return NULL;
28750 }
28751
28752
28753 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28754 PyObject *resultobj = NULL;
28755 wxWindow *arg1 = (wxWindow *) 0 ;
28756 wxWindow *arg2 = (wxWindow *) 0 ;
28757 wxWindow *result;
28758 PyObject * obj0 = 0 ;
28759 PyObject * obj1 = 0 ;
28760 char *kwnames[] = {
28761 (char *) "self",(char *) "child", NULL
28762 };
28763
28764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28766 if (SWIG_arg_fail(1)) SWIG_fail;
28767 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28768 if (SWIG_arg_fail(2)) SWIG_fail;
28769 {
28770 PyThreadState* __tstate = wxPyBeginAllowThreads();
28771 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
28772
28773 wxPyEndAllowThreads(__tstate);
28774 if (PyErr_Occurred()) SWIG_fail;
28775 }
28776 {
28777 resultobj = wxPyMake_wxObject(result, 0);
28778 }
28779 return resultobj;
28780 fail:
28781 return NULL;
28782 }
28783
28784
28785 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28786 PyObject *resultobj = NULL;
28787 wxWindow *arg1 = (wxWindow *) 0 ;
28788 wxWindow *arg2 = (wxWindow *) 0 ;
28789 PyObject * obj0 = 0 ;
28790 PyObject * obj1 = 0 ;
28791 char *kwnames[] = {
28792 (char *) "self",(char *) "win", NULL
28793 };
28794
28795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28797 if (SWIG_arg_fail(1)) SWIG_fail;
28798 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28799 if (SWIG_arg_fail(2)) SWIG_fail;
28800 {
28801 PyThreadState* __tstate = wxPyBeginAllowThreads();
28802 (arg1)->SetTmpDefaultItem(arg2);
28803
28804 wxPyEndAllowThreads(__tstate);
28805 if (PyErr_Occurred()) SWIG_fail;
28806 }
28807 Py_INCREF(Py_None); resultobj = Py_None;
28808 return resultobj;
28809 fail:
28810 return NULL;
28811 }
28812
28813
28814 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28815 PyObject *resultobj = NULL;
28816 wxWindow *arg1 = (wxWindow *) 0 ;
28817 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28818 bool result;
28819 PyObject * obj0 = 0 ;
28820 PyObject * obj1 = 0 ;
28821 char *kwnames[] = {
28822 (char *) "self",(char *) "flags", NULL
28823 };
28824
28825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28827 if (SWIG_arg_fail(1)) SWIG_fail;
28828 if (obj1) {
28829 {
28830 arg2 = static_cast<int >(SWIG_As_int(obj1));
28831 if (SWIG_arg_fail(2)) SWIG_fail;
28832 }
28833 }
28834 {
28835 PyThreadState* __tstate = wxPyBeginAllowThreads();
28836 result = (bool)(arg1)->Navigate(arg2);
28837
28838 wxPyEndAllowThreads(__tstate);
28839 if (PyErr_Occurred()) SWIG_fail;
28840 }
28841 {
28842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28843 }
28844 return resultobj;
28845 fail:
28846 return NULL;
28847 }
28848
28849
28850 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28851 PyObject *resultobj = NULL;
28852 wxWindow *arg1 = (wxWindow *) 0 ;
28853 wxWindow *arg2 = (wxWindow *) 0 ;
28854 PyObject * obj0 = 0 ;
28855 PyObject * obj1 = 0 ;
28856 char *kwnames[] = {
28857 (char *) "self",(char *) "win", NULL
28858 };
28859
28860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28862 if (SWIG_arg_fail(1)) SWIG_fail;
28863 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28864 if (SWIG_arg_fail(2)) SWIG_fail;
28865 {
28866 PyThreadState* __tstate = wxPyBeginAllowThreads();
28867 (arg1)->MoveAfterInTabOrder(arg2);
28868
28869 wxPyEndAllowThreads(__tstate);
28870 if (PyErr_Occurred()) SWIG_fail;
28871 }
28872 Py_INCREF(Py_None); resultobj = Py_None;
28873 return resultobj;
28874 fail:
28875 return NULL;
28876 }
28877
28878
28879 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28880 PyObject *resultobj = NULL;
28881 wxWindow *arg1 = (wxWindow *) 0 ;
28882 wxWindow *arg2 = (wxWindow *) 0 ;
28883 PyObject * obj0 = 0 ;
28884 PyObject * obj1 = 0 ;
28885 char *kwnames[] = {
28886 (char *) "self",(char *) "win", NULL
28887 };
28888
28889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28891 if (SWIG_arg_fail(1)) SWIG_fail;
28892 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28893 if (SWIG_arg_fail(2)) SWIG_fail;
28894 {
28895 PyThreadState* __tstate = wxPyBeginAllowThreads();
28896 (arg1)->MoveBeforeInTabOrder(arg2);
28897
28898 wxPyEndAllowThreads(__tstate);
28899 if (PyErr_Occurred()) SWIG_fail;
28900 }
28901 Py_INCREF(Py_None); resultobj = Py_None;
28902 return resultobj;
28903 fail:
28904 return NULL;
28905 }
28906
28907
28908 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28909 PyObject *resultobj = NULL;
28910 wxWindow *arg1 = (wxWindow *) 0 ;
28911 PyObject *result;
28912 PyObject * obj0 = 0 ;
28913 char *kwnames[] = {
28914 (char *) "self", NULL
28915 };
28916
28917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28919 if (SWIG_arg_fail(1)) SWIG_fail;
28920 {
28921 PyThreadState* __tstate = wxPyBeginAllowThreads();
28922 result = (PyObject *)wxWindow_GetChildren(arg1);
28923
28924 wxPyEndAllowThreads(__tstate);
28925 if (PyErr_Occurred()) SWIG_fail;
28926 }
28927 resultobj = result;
28928 return resultobj;
28929 fail:
28930 return NULL;
28931 }
28932
28933
28934 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28935 PyObject *resultobj = NULL;
28936 wxWindow *arg1 = (wxWindow *) 0 ;
28937 wxWindow *result;
28938 PyObject * obj0 = 0 ;
28939 char *kwnames[] = {
28940 (char *) "self", NULL
28941 };
28942
28943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28945 if (SWIG_arg_fail(1)) SWIG_fail;
28946 {
28947 PyThreadState* __tstate = wxPyBeginAllowThreads();
28948 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28949
28950 wxPyEndAllowThreads(__tstate);
28951 if (PyErr_Occurred()) SWIG_fail;
28952 }
28953 {
28954 resultobj = wxPyMake_wxObject(result, 0);
28955 }
28956 return resultobj;
28957 fail:
28958 return NULL;
28959 }
28960
28961
28962 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28963 PyObject *resultobj = NULL;
28964 wxWindow *arg1 = (wxWindow *) 0 ;
28965 wxWindow *result;
28966 PyObject * obj0 = 0 ;
28967 char *kwnames[] = {
28968 (char *) "self", NULL
28969 };
28970
28971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28973 if (SWIG_arg_fail(1)) SWIG_fail;
28974 {
28975 PyThreadState* __tstate = wxPyBeginAllowThreads();
28976 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28977
28978 wxPyEndAllowThreads(__tstate);
28979 if (PyErr_Occurred()) SWIG_fail;
28980 }
28981 {
28982 resultobj = wxPyMake_wxObject(result, 0);
28983 }
28984 return resultobj;
28985 fail:
28986 return NULL;
28987 }
28988
28989
28990 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28991 PyObject *resultobj = NULL;
28992 wxWindow *arg1 = (wxWindow *) 0 ;
28993 bool result;
28994 PyObject * obj0 = 0 ;
28995 char *kwnames[] = {
28996 (char *) "self", NULL
28997 };
28998
28999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
29000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29001 if (SWIG_arg_fail(1)) SWIG_fail;
29002 {
29003 PyThreadState* __tstate = wxPyBeginAllowThreads();
29004 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
29005
29006 wxPyEndAllowThreads(__tstate);
29007 if (PyErr_Occurred()) SWIG_fail;
29008 }
29009 {
29010 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29011 }
29012 return resultobj;
29013 fail:
29014 return NULL;
29015 }
29016
29017
29018 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
29019 PyObject *resultobj = NULL;
29020 wxWindow *arg1 = (wxWindow *) 0 ;
29021 wxWindow *arg2 = (wxWindow *) 0 ;
29022 bool result;
29023 PyObject * obj0 = 0 ;
29024 PyObject * obj1 = 0 ;
29025 char *kwnames[] = {
29026 (char *) "self",(char *) "newParent", NULL
29027 };
29028
29029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
29030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29031 if (SWIG_arg_fail(1)) SWIG_fail;
29032 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29033 if (SWIG_arg_fail(2)) SWIG_fail;
29034 {
29035 PyThreadState* __tstate = wxPyBeginAllowThreads();
29036 result = (bool)(arg1)->Reparent(arg2);
29037
29038 wxPyEndAllowThreads(__tstate);
29039 if (PyErr_Occurred()) SWIG_fail;
29040 }
29041 {
29042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29043 }
29044 return resultobj;
29045 fail:
29046 return NULL;
29047 }
29048
29049
29050 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
29051 PyObject *resultobj = NULL;
29052 wxWindow *arg1 = (wxWindow *) 0 ;
29053 wxWindow *arg2 = (wxWindow *) 0 ;
29054 PyObject * obj0 = 0 ;
29055 PyObject * obj1 = 0 ;
29056 char *kwnames[] = {
29057 (char *) "self",(char *) "child", NULL
29058 };
29059
29060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
29061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29062 if (SWIG_arg_fail(1)) SWIG_fail;
29063 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29064 if (SWIG_arg_fail(2)) SWIG_fail;
29065 {
29066 PyThreadState* __tstate = wxPyBeginAllowThreads();
29067 (arg1)->AddChild(arg2);
29068
29069 wxPyEndAllowThreads(__tstate);
29070 if (PyErr_Occurred()) SWIG_fail;
29071 }
29072 Py_INCREF(Py_None); resultobj = Py_None;
29073 return resultobj;
29074 fail:
29075 return NULL;
29076 }
29077
29078
29079 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
29080 PyObject *resultobj = NULL;
29081 wxWindow *arg1 = (wxWindow *) 0 ;
29082 wxWindow *arg2 = (wxWindow *) 0 ;
29083 PyObject * obj0 = 0 ;
29084 PyObject * obj1 = 0 ;
29085 char *kwnames[] = {
29086 (char *) "self",(char *) "child", NULL
29087 };
29088
29089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
29090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29091 if (SWIG_arg_fail(1)) SWIG_fail;
29092 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29093 if (SWIG_arg_fail(2)) SWIG_fail;
29094 {
29095 PyThreadState* __tstate = wxPyBeginAllowThreads();
29096 (arg1)->RemoveChild(arg2);
29097
29098 wxPyEndAllowThreads(__tstate);
29099 if (PyErr_Occurred()) SWIG_fail;
29100 }
29101 Py_INCREF(Py_None); resultobj = Py_None;
29102 return resultobj;
29103 fail:
29104 return NULL;
29105 }
29106
29107
29108 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
29109 PyObject *resultobj = NULL;
29110 wxWindow *arg1 = (wxWindow *) 0 ;
29111 long arg2 ;
29112 wxWindow *result;
29113 PyObject * obj0 = 0 ;
29114 PyObject * obj1 = 0 ;
29115 char *kwnames[] = {
29116 (char *) "self",(char *) "winid", NULL
29117 };
29118
29119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
29120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29121 if (SWIG_arg_fail(1)) SWIG_fail;
29122 {
29123 arg2 = static_cast<long >(SWIG_As_long(obj1));
29124 if (SWIG_arg_fail(2)) SWIG_fail;
29125 }
29126 {
29127 PyThreadState* __tstate = wxPyBeginAllowThreads();
29128 result = (wxWindow *)(arg1)->FindWindow(arg2);
29129
29130 wxPyEndAllowThreads(__tstate);
29131 if (PyErr_Occurred()) SWIG_fail;
29132 }
29133 {
29134 resultobj = wxPyMake_wxObject(result, 0);
29135 }
29136 return resultobj;
29137 fail:
29138 return NULL;
29139 }
29140
29141
29142 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
29143 PyObject *resultobj = NULL;
29144 wxWindow *arg1 = (wxWindow *) 0 ;
29145 wxString *arg2 = 0 ;
29146 wxWindow *result;
29147 bool temp2 = false ;
29148 PyObject * obj0 = 0 ;
29149 PyObject * obj1 = 0 ;
29150 char *kwnames[] = {
29151 (char *) "self",(char *) "name", NULL
29152 };
29153
29154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
29155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29156 if (SWIG_arg_fail(1)) SWIG_fail;
29157 {
29158 arg2 = wxString_in_helper(obj1);
29159 if (arg2 == NULL) SWIG_fail;
29160 temp2 = true;
29161 }
29162 {
29163 PyThreadState* __tstate = wxPyBeginAllowThreads();
29164 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
29165
29166 wxPyEndAllowThreads(__tstate);
29167 if (PyErr_Occurred()) SWIG_fail;
29168 }
29169 {
29170 resultobj = wxPyMake_wxObject(result, 0);
29171 }
29172 {
29173 if (temp2)
29174 delete arg2;
29175 }
29176 return resultobj;
29177 fail:
29178 {
29179 if (temp2)
29180 delete arg2;
29181 }
29182 return NULL;
29183 }
29184
29185
29186 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29187 PyObject *resultobj = NULL;
29188 wxWindow *arg1 = (wxWindow *) 0 ;
29189 wxEvtHandler *result;
29190 PyObject * obj0 = 0 ;
29191 char *kwnames[] = {
29192 (char *) "self", NULL
29193 };
29194
29195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
29196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29197 if (SWIG_arg_fail(1)) SWIG_fail;
29198 {
29199 PyThreadState* __tstate = wxPyBeginAllowThreads();
29200 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
29201
29202 wxPyEndAllowThreads(__tstate);
29203 if (PyErr_Occurred()) SWIG_fail;
29204 }
29205 {
29206 resultobj = wxPyMake_wxObject(result, 0);
29207 }
29208 return resultobj;
29209 fail:
29210 return NULL;
29211 }
29212
29213
29214 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29215 PyObject *resultobj = NULL;
29216 wxWindow *arg1 = (wxWindow *) 0 ;
29217 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29218 PyObject * obj0 = 0 ;
29219 PyObject * obj1 = 0 ;
29220 char *kwnames[] = {
29221 (char *) "self",(char *) "handler", NULL
29222 };
29223
29224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
29225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29226 if (SWIG_arg_fail(1)) SWIG_fail;
29227 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29228 if (SWIG_arg_fail(2)) SWIG_fail;
29229 {
29230 PyThreadState* __tstate = wxPyBeginAllowThreads();
29231 (arg1)->SetEventHandler(arg2);
29232
29233 wxPyEndAllowThreads(__tstate);
29234 if (PyErr_Occurred()) SWIG_fail;
29235 }
29236 Py_INCREF(Py_None); resultobj = Py_None;
29237 return resultobj;
29238 fail:
29239 return NULL;
29240 }
29241
29242
29243 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29244 PyObject *resultobj = NULL;
29245 wxWindow *arg1 = (wxWindow *) 0 ;
29246 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29247 PyObject * obj0 = 0 ;
29248 PyObject * obj1 = 0 ;
29249 char *kwnames[] = {
29250 (char *) "self",(char *) "handler", NULL
29251 };
29252
29253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
29254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29255 if (SWIG_arg_fail(1)) SWIG_fail;
29256 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29257 if (SWIG_arg_fail(2)) SWIG_fail;
29258 {
29259 PyThreadState* __tstate = wxPyBeginAllowThreads();
29260 (arg1)->PushEventHandler(arg2);
29261
29262 wxPyEndAllowThreads(__tstate);
29263 if (PyErr_Occurred()) SWIG_fail;
29264 }
29265 Py_INCREF(Py_None); resultobj = Py_None;
29266 return resultobj;
29267 fail:
29268 return NULL;
29269 }
29270
29271
29272 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29273 PyObject *resultobj = NULL;
29274 wxWindow *arg1 = (wxWindow *) 0 ;
29275 bool arg2 = (bool) false ;
29276 wxEvtHandler *result;
29277 PyObject * obj0 = 0 ;
29278 PyObject * obj1 = 0 ;
29279 char *kwnames[] = {
29280 (char *) "self",(char *) "deleteHandler", NULL
29281 };
29282
29283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
29284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29285 if (SWIG_arg_fail(1)) SWIG_fail;
29286 if (obj1) {
29287 {
29288 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
29289 if (SWIG_arg_fail(2)) SWIG_fail;
29290 }
29291 }
29292 {
29293 PyThreadState* __tstate = wxPyBeginAllowThreads();
29294 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
29295
29296 wxPyEndAllowThreads(__tstate);
29297 if (PyErr_Occurred()) SWIG_fail;
29298 }
29299 {
29300 resultobj = wxPyMake_wxObject(result, 0);
29301 }
29302 return resultobj;
29303 fail:
29304 return NULL;
29305 }
29306
29307
29308 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29309 PyObject *resultobj = NULL;
29310 wxWindow *arg1 = (wxWindow *) 0 ;
29311 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29312 bool result;
29313 PyObject * obj0 = 0 ;
29314 PyObject * obj1 = 0 ;
29315 char *kwnames[] = {
29316 (char *) "self",(char *) "handler", NULL
29317 };
29318
29319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
29320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29321 if (SWIG_arg_fail(1)) SWIG_fail;
29322 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29323 if (SWIG_arg_fail(2)) SWIG_fail;
29324 {
29325 PyThreadState* __tstate = wxPyBeginAllowThreads();
29326 result = (bool)(arg1)->RemoveEventHandler(arg2);
29327
29328 wxPyEndAllowThreads(__tstate);
29329 if (PyErr_Occurred()) SWIG_fail;
29330 }
29331 {
29332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29333 }
29334 return resultobj;
29335 fail:
29336 return NULL;
29337 }
29338
29339
29340 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29341 PyObject *resultobj = NULL;
29342 wxWindow *arg1 = (wxWindow *) 0 ;
29343 wxValidator *arg2 = 0 ;
29344 PyObject * obj0 = 0 ;
29345 PyObject * obj1 = 0 ;
29346 char *kwnames[] = {
29347 (char *) "self",(char *) "validator", NULL
29348 };
29349
29350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
29351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29352 if (SWIG_arg_fail(1)) SWIG_fail;
29353 {
29354 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
29355 if (SWIG_arg_fail(2)) SWIG_fail;
29356 if (arg2 == NULL) {
29357 SWIG_null_ref("wxValidator");
29358 }
29359 if (SWIG_arg_fail(2)) SWIG_fail;
29360 }
29361 {
29362 PyThreadState* __tstate = wxPyBeginAllowThreads();
29363 (arg1)->SetValidator((wxValidator const &)*arg2);
29364
29365 wxPyEndAllowThreads(__tstate);
29366 if (PyErr_Occurred()) SWIG_fail;
29367 }
29368 Py_INCREF(Py_None); resultobj = Py_None;
29369 return resultobj;
29370 fail:
29371 return NULL;
29372 }
29373
29374
29375 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29376 PyObject *resultobj = NULL;
29377 wxWindow *arg1 = (wxWindow *) 0 ;
29378 wxValidator *result;
29379 PyObject * obj0 = 0 ;
29380 char *kwnames[] = {
29381 (char *) "self", NULL
29382 };
29383
29384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
29385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29386 if (SWIG_arg_fail(1)) SWIG_fail;
29387 {
29388 PyThreadState* __tstate = wxPyBeginAllowThreads();
29389 result = (wxValidator *)(arg1)->GetValidator();
29390
29391 wxPyEndAllowThreads(__tstate);
29392 if (PyErr_Occurred()) SWIG_fail;
29393 }
29394 {
29395 resultobj = wxPyMake_wxObject(result, (bool)0);
29396 }
29397 return resultobj;
29398 fail:
29399 return NULL;
29400 }
29401
29402
29403 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
29404 PyObject *resultobj = NULL;
29405 wxWindow *arg1 = (wxWindow *) 0 ;
29406 bool result;
29407 PyObject * obj0 = 0 ;
29408 char *kwnames[] = {
29409 (char *) "self", NULL
29410 };
29411
29412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
29413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29414 if (SWIG_arg_fail(1)) SWIG_fail;
29415 {
29416 PyThreadState* __tstate = wxPyBeginAllowThreads();
29417 result = (bool)(arg1)->Validate();
29418
29419 wxPyEndAllowThreads(__tstate);
29420 if (PyErr_Occurred()) SWIG_fail;
29421 }
29422 {
29423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29424 }
29425 return resultobj;
29426 fail:
29427 return NULL;
29428 }
29429
29430
29431 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29432 PyObject *resultobj = NULL;
29433 wxWindow *arg1 = (wxWindow *) 0 ;
29434 bool result;
29435 PyObject * obj0 = 0 ;
29436 char *kwnames[] = {
29437 (char *) "self", NULL
29438 };
29439
29440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
29441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29442 if (SWIG_arg_fail(1)) SWIG_fail;
29443 {
29444 PyThreadState* __tstate = wxPyBeginAllowThreads();
29445 result = (bool)(arg1)->TransferDataToWindow();
29446
29447 wxPyEndAllowThreads(__tstate);
29448 if (PyErr_Occurred()) SWIG_fail;
29449 }
29450 {
29451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29452 }
29453 return resultobj;
29454 fail:
29455 return NULL;
29456 }
29457
29458
29459 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29460 PyObject *resultobj = NULL;
29461 wxWindow *arg1 = (wxWindow *) 0 ;
29462 bool result;
29463 PyObject * obj0 = 0 ;
29464 char *kwnames[] = {
29465 (char *) "self", NULL
29466 };
29467
29468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
29469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29470 if (SWIG_arg_fail(1)) SWIG_fail;
29471 {
29472 PyThreadState* __tstate = wxPyBeginAllowThreads();
29473 result = (bool)(arg1)->TransferDataFromWindow();
29474
29475 wxPyEndAllowThreads(__tstate);
29476 if (PyErr_Occurred()) SWIG_fail;
29477 }
29478 {
29479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29480 }
29481 return resultobj;
29482 fail:
29483 return NULL;
29484 }
29485
29486
29487 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29488 PyObject *resultobj = NULL;
29489 wxWindow *arg1 = (wxWindow *) 0 ;
29490 PyObject * obj0 = 0 ;
29491 char *kwnames[] = {
29492 (char *) "self", NULL
29493 };
29494
29495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
29496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29497 if (SWIG_arg_fail(1)) SWIG_fail;
29498 {
29499 PyThreadState* __tstate = wxPyBeginAllowThreads();
29500 (arg1)->InitDialog();
29501
29502 wxPyEndAllowThreads(__tstate);
29503 if (PyErr_Occurred()) SWIG_fail;
29504 }
29505 Py_INCREF(Py_None); resultobj = Py_None;
29506 return resultobj;
29507 fail:
29508 return NULL;
29509 }
29510
29511
29512 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29513 PyObject *resultobj = NULL;
29514 wxWindow *arg1 = (wxWindow *) 0 ;
29515 wxAcceleratorTable *arg2 = 0 ;
29516 PyObject * obj0 = 0 ;
29517 PyObject * obj1 = 0 ;
29518 char *kwnames[] = {
29519 (char *) "self",(char *) "accel", NULL
29520 };
29521
29522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
29523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29524 if (SWIG_arg_fail(1)) SWIG_fail;
29525 {
29526 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
29527 if (SWIG_arg_fail(2)) SWIG_fail;
29528 if (arg2 == NULL) {
29529 SWIG_null_ref("wxAcceleratorTable");
29530 }
29531 if (SWIG_arg_fail(2)) SWIG_fail;
29532 }
29533 {
29534 PyThreadState* __tstate = wxPyBeginAllowThreads();
29535 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
29536
29537 wxPyEndAllowThreads(__tstate);
29538 if (PyErr_Occurred()) SWIG_fail;
29539 }
29540 Py_INCREF(Py_None); resultobj = Py_None;
29541 return resultobj;
29542 fail:
29543 return NULL;
29544 }
29545
29546
29547 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29548 PyObject *resultobj = NULL;
29549 wxWindow *arg1 = (wxWindow *) 0 ;
29550 wxAcceleratorTable *result;
29551 PyObject * obj0 = 0 ;
29552 char *kwnames[] = {
29553 (char *) "self", NULL
29554 };
29555
29556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
29557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29558 if (SWIG_arg_fail(1)) SWIG_fail;
29559 {
29560 PyThreadState* __tstate = wxPyBeginAllowThreads();
29561 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
29562
29563 wxPyEndAllowThreads(__tstate);
29564 if (PyErr_Occurred()) SWIG_fail;
29565 }
29566 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
29567 return resultobj;
29568 fail:
29569 return NULL;
29570 }
29571
29572
29573 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29574 PyObject *resultobj = NULL;
29575 wxWindow *arg1 = (wxWindow *) 0 ;
29576 int arg2 ;
29577 int arg3 ;
29578 int arg4 ;
29579 bool result;
29580 PyObject * obj0 = 0 ;
29581 PyObject * obj1 = 0 ;
29582 PyObject * obj2 = 0 ;
29583 PyObject * obj3 = 0 ;
29584 char *kwnames[] = {
29585 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
29586 };
29587
29588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29590 if (SWIG_arg_fail(1)) SWIG_fail;
29591 {
29592 arg2 = static_cast<int >(SWIG_As_int(obj1));
29593 if (SWIG_arg_fail(2)) SWIG_fail;
29594 }
29595 {
29596 arg3 = static_cast<int >(SWIG_As_int(obj2));
29597 if (SWIG_arg_fail(3)) SWIG_fail;
29598 }
29599 {
29600 arg4 = static_cast<int >(SWIG_As_int(obj3));
29601 if (SWIG_arg_fail(4)) SWIG_fail;
29602 }
29603 {
29604 PyThreadState* __tstate = wxPyBeginAllowThreads();
29605 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
29606
29607 wxPyEndAllowThreads(__tstate);
29608 if (PyErr_Occurred()) SWIG_fail;
29609 }
29610 {
29611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29612 }
29613 return resultobj;
29614 fail:
29615 return NULL;
29616 }
29617
29618
29619 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29620 PyObject *resultobj = NULL;
29621 wxWindow *arg1 = (wxWindow *) 0 ;
29622 int arg2 ;
29623 bool result;
29624 PyObject * obj0 = 0 ;
29625 PyObject * obj1 = 0 ;
29626 char *kwnames[] = {
29627 (char *) "self",(char *) "hotkeyId", NULL
29628 };
29629
29630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
29631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29632 if (SWIG_arg_fail(1)) SWIG_fail;
29633 {
29634 arg2 = static_cast<int >(SWIG_As_int(obj1));
29635 if (SWIG_arg_fail(2)) SWIG_fail;
29636 }
29637 {
29638 PyThreadState* __tstate = wxPyBeginAllowThreads();
29639 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
29640
29641 wxPyEndAllowThreads(__tstate);
29642 if (PyErr_Occurred()) SWIG_fail;
29643 }
29644 {
29645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29646 }
29647 return resultobj;
29648 fail:
29649 return NULL;
29650 }
29651
29652
29653 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29654 PyObject *resultobj = NULL;
29655 wxWindow *arg1 = (wxWindow *) 0 ;
29656 wxPoint *arg2 = 0 ;
29657 wxPoint result;
29658 wxPoint temp2 ;
29659 PyObject * obj0 = 0 ;
29660 PyObject * obj1 = 0 ;
29661 char *kwnames[] = {
29662 (char *) "self",(char *) "pt", NULL
29663 };
29664
29665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
29666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29667 if (SWIG_arg_fail(1)) SWIG_fail;
29668 {
29669 arg2 = &temp2;
29670 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29671 }
29672 {
29673 PyThreadState* __tstate = wxPyBeginAllowThreads();
29674 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29675
29676 wxPyEndAllowThreads(__tstate);
29677 if (PyErr_Occurred()) SWIG_fail;
29678 }
29679 {
29680 wxPoint * resultptr;
29681 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29682 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29683 }
29684 return resultobj;
29685 fail:
29686 return NULL;
29687 }
29688
29689
29690 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29691 PyObject *resultobj = NULL;
29692 wxWindow *arg1 = (wxWindow *) 0 ;
29693 wxSize *arg2 = 0 ;
29694 wxSize result;
29695 wxSize temp2 ;
29696 PyObject * obj0 = 0 ;
29697 PyObject * obj1 = 0 ;
29698 char *kwnames[] = {
29699 (char *) "self",(char *) "sz", NULL
29700 };
29701
29702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
29703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29704 if (SWIG_arg_fail(1)) SWIG_fail;
29705 {
29706 arg2 = &temp2;
29707 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29708 }
29709 {
29710 PyThreadState* __tstate = wxPyBeginAllowThreads();
29711 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29712
29713 wxPyEndAllowThreads(__tstate);
29714 if (PyErr_Occurred()) SWIG_fail;
29715 }
29716 {
29717 wxSize * resultptr;
29718 resultptr = new wxSize(static_cast<wxSize & >(result));
29719 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29720 }
29721 return resultobj;
29722 fail:
29723 return NULL;
29724 }
29725
29726
29727 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
29728 PyObject *resultobj = NULL;
29729 wxWindow *arg1 = (wxWindow *) 0 ;
29730 wxPoint *arg2 = 0 ;
29731 wxPoint result;
29732 wxPoint temp2 ;
29733 PyObject * obj0 = 0 ;
29734 PyObject * obj1 = 0 ;
29735 char *kwnames[] = {
29736 (char *) "self",(char *) "pt", NULL
29737 };
29738
29739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
29740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29741 if (SWIG_arg_fail(1)) SWIG_fail;
29742 {
29743 arg2 = &temp2;
29744 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29745 }
29746 {
29747 PyThreadState* __tstate = wxPyBeginAllowThreads();
29748 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29749
29750 wxPyEndAllowThreads(__tstate);
29751 if (PyErr_Occurred()) SWIG_fail;
29752 }
29753 {
29754 wxPoint * resultptr;
29755 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29756 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29757 }
29758 return resultobj;
29759 fail:
29760 return NULL;
29761 }
29762
29763
29764 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
29765 PyObject *resultobj = NULL;
29766 wxWindow *arg1 = (wxWindow *) 0 ;
29767 wxSize *arg2 = 0 ;
29768 wxSize result;
29769 wxSize temp2 ;
29770 PyObject * obj0 = 0 ;
29771 PyObject * obj1 = 0 ;
29772 char *kwnames[] = {
29773 (char *) "self",(char *) "sz", NULL
29774 };
29775
29776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29778 if (SWIG_arg_fail(1)) SWIG_fail;
29779 {
29780 arg2 = &temp2;
29781 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29782 }
29783 {
29784 PyThreadState* __tstate = wxPyBeginAllowThreads();
29785 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29786
29787 wxPyEndAllowThreads(__tstate);
29788 if (PyErr_Occurred()) SWIG_fail;
29789 }
29790 {
29791 wxSize * resultptr;
29792 resultptr = new wxSize(static_cast<wxSize & >(result));
29793 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29794 }
29795 return resultobj;
29796 fail:
29797 return NULL;
29798 }
29799
29800
29801 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29802 PyObject *resultobj = NULL;
29803 wxWindow *arg1 = (wxWindow *) 0 ;
29804 wxPoint *arg2 = 0 ;
29805 wxPoint result;
29806 wxPoint temp2 ;
29807 PyObject * obj0 = 0 ;
29808 PyObject * obj1 = 0 ;
29809 char *kwnames[] = {
29810 (char *) "self",(char *) "pt", NULL
29811 };
29812
29813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29815 if (SWIG_arg_fail(1)) SWIG_fail;
29816 {
29817 arg2 = &temp2;
29818 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29819 }
29820 {
29821 PyThreadState* __tstate = wxPyBeginAllowThreads();
29822 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29823
29824 wxPyEndAllowThreads(__tstate);
29825 if (PyErr_Occurred()) SWIG_fail;
29826 }
29827 {
29828 wxPoint * resultptr;
29829 resultptr = new wxPoint(static_cast<wxPoint & >(result));
29830 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29831 }
29832 return resultobj;
29833 fail:
29834 return NULL;
29835 }
29836
29837
29838 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29839 PyObject *resultobj = NULL;
29840 wxWindow *arg1 = (wxWindow *) 0 ;
29841 wxSize *arg2 = 0 ;
29842 wxSize result;
29843 wxSize temp2 ;
29844 PyObject * obj0 = 0 ;
29845 PyObject * obj1 = 0 ;
29846 char *kwnames[] = {
29847 (char *) "self",(char *) "sz", NULL
29848 };
29849
29850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29852 if (SWIG_arg_fail(1)) SWIG_fail;
29853 {
29854 arg2 = &temp2;
29855 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29856 }
29857 {
29858 PyThreadState* __tstate = wxPyBeginAllowThreads();
29859 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29860
29861 wxPyEndAllowThreads(__tstate);
29862 if (PyErr_Occurred()) SWIG_fail;
29863 }
29864 {
29865 wxSize * resultptr;
29866 resultptr = new wxSize(static_cast<wxSize & >(result));
29867 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29868 }
29869 return resultobj;
29870 fail:
29871 return NULL;
29872 }
29873
29874
29875 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29876 PyObject *resultobj = NULL;
29877 wxWindow *arg1 = (wxWindow *) 0 ;
29878 int arg2 ;
29879 int arg3 ;
29880 PyObject * obj0 = 0 ;
29881 PyObject * obj1 = 0 ;
29882 PyObject * obj2 = 0 ;
29883 char *kwnames[] = {
29884 (char *) "self",(char *) "x",(char *) "y", NULL
29885 };
29886
29887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29889 if (SWIG_arg_fail(1)) SWIG_fail;
29890 {
29891 arg2 = static_cast<int >(SWIG_As_int(obj1));
29892 if (SWIG_arg_fail(2)) SWIG_fail;
29893 }
29894 {
29895 arg3 = static_cast<int >(SWIG_As_int(obj2));
29896 if (SWIG_arg_fail(3)) SWIG_fail;
29897 }
29898 {
29899 PyThreadState* __tstate = wxPyBeginAllowThreads();
29900 (arg1)->WarpPointer(arg2,arg3);
29901
29902 wxPyEndAllowThreads(__tstate);
29903 if (PyErr_Occurred()) SWIG_fail;
29904 }
29905 Py_INCREF(Py_None); resultobj = Py_None;
29906 return resultobj;
29907 fail:
29908 return NULL;
29909 }
29910
29911
29912 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29913 PyObject *resultobj = NULL;
29914 wxWindow *arg1 = (wxWindow *) 0 ;
29915 PyObject * obj0 = 0 ;
29916 char *kwnames[] = {
29917 (char *) "self", NULL
29918 };
29919
29920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29922 if (SWIG_arg_fail(1)) SWIG_fail;
29923 {
29924 PyThreadState* __tstate = wxPyBeginAllowThreads();
29925 (arg1)->CaptureMouse();
29926
29927 wxPyEndAllowThreads(__tstate);
29928 if (PyErr_Occurred()) SWIG_fail;
29929 }
29930 Py_INCREF(Py_None); resultobj = Py_None;
29931 return resultobj;
29932 fail:
29933 return NULL;
29934 }
29935
29936
29937 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29938 PyObject *resultobj = NULL;
29939 wxWindow *arg1 = (wxWindow *) 0 ;
29940 PyObject * obj0 = 0 ;
29941 char *kwnames[] = {
29942 (char *) "self", NULL
29943 };
29944
29945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29947 if (SWIG_arg_fail(1)) SWIG_fail;
29948 {
29949 PyThreadState* __tstate = wxPyBeginAllowThreads();
29950 (arg1)->ReleaseMouse();
29951
29952 wxPyEndAllowThreads(__tstate);
29953 if (PyErr_Occurred()) SWIG_fail;
29954 }
29955 Py_INCREF(Py_None); resultobj = Py_None;
29956 return resultobj;
29957 fail:
29958 return NULL;
29959 }
29960
29961
29962 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29963 PyObject *resultobj = NULL;
29964 wxWindow *result;
29965 char *kwnames[] = {
29966 NULL
29967 };
29968
29969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29970 {
29971 if (!wxPyCheckForApp()) SWIG_fail;
29972 PyThreadState* __tstate = wxPyBeginAllowThreads();
29973 result = (wxWindow *)wxWindow::GetCapture();
29974
29975 wxPyEndAllowThreads(__tstate);
29976 if (PyErr_Occurred()) SWIG_fail;
29977 }
29978 {
29979 resultobj = wxPyMake_wxObject(result, 0);
29980 }
29981 return resultobj;
29982 fail:
29983 return NULL;
29984 }
29985
29986
29987 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29988 PyObject *resultobj = NULL;
29989 wxWindow *arg1 = (wxWindow *) 0 ;
29990 bool result;
29991 PyObject * obj0 = 0 ;
29992 char *kwnames[] = {
29993 (char *) "self", NULL
29994 };
29995
29996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29998 if (SWIG_arg_fail(1)) SWIG_fail;
29999 {
30000 PyThreadState* __tstate = wxPyBeginAllowThreads();
30001 result = (bool)((wxWindow const *)arg1)->HasCapture();
30002
30003 wxPyEndAllowThreads(__tstate);
30004 if (PyErr_Occurred()) SWIG_fail;
30005 }
30006 {
30007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30008 }
30009 return resultobj;
30010 fail:
30011 return NULL;
30012 }
30013
30014
30015 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
30016 PyObject *resultobj = NULL;
30017 wxWindow *arg1 = (wxWindow *) 0 ;
30018 bool arg2 = (bool) true ;
30019 wxRect *arg3 = (wxRect *) NULL ;
30020 PyObject * obj0 = 0 ;
30021 PyObject * obj1 = 0 ;
30022 PyObject * obj2 = 0 ;
30023 char *kwnames[] = {
30024 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
30025 };
30026
30027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
30028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30029 if (SWIG_arg_fail(1)) SWIG_fail;
30030 if (obj1) {
30031 {
30032 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
30033 if (SWIG_arg_fail(2)) SWIG_fail;
30034 }
30035 }
30036 if (obj2) {
30037 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30038 if (SWIG_arg_fail(3)) SWIG_fail;
30039 }
30040 {
30041 PyThreadState* __tstate = wxPyBeginAllowThreads();
30042 (arg1)->Refresh(arg2,(wxRect const *)arg3);
30043
30044 wxPyEndAllowThreads(__tstate);
30045 if (PyErr_Occurred()) SWIG_fail;
30046 }
30047 Py_INCREF(Py_None); resultobj = Py_None;
30048 return resultobj;
30049 fail:
30050 return NULL;
30051 }
30052
30053
30054 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
30055 PyObject *resultobj = NULL;
30056 wxWindow *arg1 = (wxWindow *) 0 ;
30057 wxRect *arg2 = 0 ;
30058 bool arg3 = (bool) true ;
30059 wxRect temp2 ;
30060 PyObject * obj0 = 0 ;
30061 PyObject * obj1 = 0 ;
30062 PyObject * obj2 = 0 ;
30063 char *kwnames[] = {
30064 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
30065 };
30066
30067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
30068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30069 if (SWIG_arg_fail(1)) SWIG_fail;
30070 {
30071 arg2 = &temp2;
30072 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30073 }
30074 if (obj2) {
30075 {
30076 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
30077 if (SWIG_arg_fail(3)) SWIG_fail;
30078 }
30079 }
30080 {
30081 PyThreadState* __tstate = wxPyBeginAllowThreads();
30082 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
30083
30084 wxPyEndAllowThreads(__tstate);
30085 if (PyErr_Occurred()) SWIG_fail;
30086 }
30087 Py_INCREF(Py_None); resultobj = Py_None;
30088 return resultobj;
30089 fail:
30090 return NULL;
30091 }
30092
30093
30094 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
30095 PyObject *resultobj = NULL;
30096 wxWindow *arg1 = (wxWindow *) 0 ;
30097 PyObject * obj0 = 0 ;
30098 char *kwnames[] = {
30099 (char *) "self", NULL
30100 };
30101
30102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
30103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30104 if (SWIG_arg_fail(1)) SWIG_fail;
30105 {
30106 PyThreadState* __tstate = wxPyBeginAllowThreads();
30107 (arg1)->Update();
30108
30109 wxPyEndAllowThreads(__tstate);
30110 if (PyErr_Occurred()) SWIG_fail;
30111 }
30112 Py_INCREF(Py_None); resultobj = Py_None;
30113 return resultobj;
30114 fail:
30115 return NULL;
30116 }
30117
30118
30119 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30120 PyObject *resultobj = NULL;
30121 wxWindow *arg1 = (wxWindow *) 0 ;
30122 PyObject * obj0 = 0 ;
30123 char *kwnames[] = {
30124 (char *) "self", NULL
30125 };
30126
30127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
30128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30129 if (SWIG_arg_fail(1)) SWIG_fail;
30130 {
30131 PyThreadState* __tstate = wxPyBeginAllowThreads();
30132 (arg1)->ClearBackground();
30133
30134 wxPyEndAllowThreads(__tstate);
30135 if (PyErr_Occurred()) SWIG_fail;
30136 }
30137 Py_INCREF(Py_None); resultobj = Py_None;
30138 return resultobj;
30139 fail:
30140 return NULL;
30141 }
30142
30143
30144 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
30145 PyObject *resultobj = NULL;
30146 wxWindow *arg1 = (wxWindow *) 0 ;
30147 PyObject * obj0 = 0 ;
30148 char *kwnames[] = {
30149 (char *) "self", NULL
30150 };
30151
30152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
30153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30154 if (SWIG_arg_fail(1)) SWIG_fail;
30155 {
30156 PyThreadState* __tstate = wxPyBeginAllowThreads();
30157 (arg1)->Freeze();
30158
30159 wxPyEndAllowThreads(__tstate);
30160 if (PyErr_Occurred()) SWIG_fail;
30161 }
30162 Py_INCREF(Py_None); resultobj = Py_None;
30163 return resultobj;
30164 fail:
30165 return NULL;
30166 }
30167
30168
30169 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
30170 PyObject *resultobj = NULL;
30171 wxWindow *arg1 = (wxWindow *) 0 ;
30172 PyObject * obj0 = 0 ;
30173 char *kwnames[] = {
30174 (char *) "self", NULL
30175 };
30176
30177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
30178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30179 if (SWIG_arg_fail(1)) SWIG_fail;
30180 {
30181 PyThreadState* __tstate = wxPyBeginAllowThreads();
30182 (arg1)->Thaw();
30183
30184 wxPyEndAllowThreads(__tstate);
30185 if (PyErr_Occurred()) SWIG_fail;
30186 }
30187 Py_INCREF(Py_None); resultobj = Py_None;
30188 return resultobj;
30189 fail:
30190 return NULL;
30191 }
30192
30193
30194 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
30195 PyObject *resultobj = NULL;
30196 wxWindow *arg1 = (wxWindow *) 0 ;
30197 wxDC *arg2 = 0 ;
30198 PyObject * obj0 = 0 ;
30199 PyObject * obj1 = 0 ;
30200 char *kwnames[] = {
30201 (char *) "self",(char *) "dc", NULL
30202 };
30203
30204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
30205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30206 if (SWIG_arg_fail(1)) SWIG_fail;
30207 {
30208 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
30209 if (SWIG_arg_fail(2)) SWIG_fail;
30210 if (arg2 == NULL) {
30211 SWIG_null_ref("wxDC");
30212 }
30213 if (SWIG_arg_fail(2)) SWIG_fail;
30214 }
30215 {
30216 PyThreadState* __tstate = wxPyBeginAllowThreads();
30217 (arg1)->PrepareDC(*arg2);
30218
30219 wxPyEndAllowThreads(__tstate);
30220 if (PyErr_Occurred()) SWIG_fail;
30221 }
30222 Py_INCREF(Py_None); resultobj = Py_None;
30223 return resultobj;
30224 fail:
30225 return NULL;
30226 }
30227
30228
30229 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
30230 PyObject *resultobj = NULL;
30231 wxWindow *arg1 = (wxWindow *) 0 ;
30232 wxRegion *result;
30233 PyObject * obj0 = 0 ;
30234 char *kwnames[] = {
30235 (char *) "self", NULL
30236 };
30237
30238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
30239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30240 if (SWIG_arg_fail(1)) SWIG_fail;
30241 {
30242 PyThreadState* __tstate = wxPyBeginAllowThreads();
30243 {
30244 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
30245 result = (wxRegion *) &_result_ref;
30246 }
30247
30248 wxPyEndAllowThreads(__tstate);
30249 if (PyErr_Occurred()) SWIG_fail;
30250 }
30251 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
30252 return resultobj;
30253 fail:
30254 return NULL;
30255 }
30256
30257
30258 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
30259 PyObject *resultobj = NULL;
30260 wxWindow *arg1 = (wxWindow *) 0 ;
30261 wxRect result;
30262 PyObject * obj0 = 0 ;
30263 char *kwnames[] = {
30264 (char *) "self", NULL
30265 };
30266
30267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
30268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30269 if (SWIG_arg_fail(1)) SWIG_fail;
30270 {
30271 PyThreadState* __tstate = wxPyBeginAllowThreads();
30272 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
30273
30274 wxPyEndAllowThreads(__tstate);
30275 if (PyErr_Occurred()) SWIG_fail;
30276 }
30277 {
30278 wxRect * resultptr;
30279 resultptr = new wxRect(static_cast<wxRect & >(result));
30280 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
30281 }
30282 return resultobj;
30283 fail:
30284 return NULL;
30285 }
30286
30287
30288 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
30289 PyObject *resultobj = NULL;
30290 wxWindow *arg1 = (wxWindow *) 0 ;
30291 int arg2 ;
30292 int arg3 ;
30293 int arg4 = (int) 1 ;
30294 int arg5 = (int) 1 ;
30295 bool result;
30296 PyObject * obj0 = 0 ;
30297 PyObject * obj1 = 0 ;
30298 PyObject * obj2 = 0 ;
30299 PyObject * obj3 = 0 ;
30300 PyObject * obj4 = 0 ;
30301 char *kwnames[] = {
30302 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
30303 };
30304
30305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
30306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30307 if (SWIG_arg_fail(1)) SWIG_fail;
30308 {
30309 arg2 = static_cast<int >(SWIG_As_int(obj1));
30310 if (SWIG_arg_fail(2)) SWIG_fail;
30311 }
30312 {
30313 arg3 = static_cast<int >(SWIG_As_int(obj2));
30314 if (SWIG_arg_fail(3)) SWIG_fail;
30315 }
30316 if (obj3) {
30317 {
30318 arg4 = static_cast<int >(SWIG_As_int(obj3));
30319 if (SWIG_arg_fail(4)) SWIG_fail;
30320 }
30321 }
30322 if (obj4) {
30323 {
30324 arg5 = static_cast<int >(SWIG_As_int(obj4));
30325 if (SWIG_arg_fail(5)) SWIG_fail;
30326 }
30327 }
30328 {
30329 PyThreadState* __tstate = wxPyBeginAllowThreads();
30330 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
30331
30332 wxPyEndAllowThreads(__tstate);
30333 if (PyErr_Occurred()) SWIG_fail;
30334 }
30335 {
30336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30337 }
30338 return resultobj;
30339 fail:
30340 return NULL;
30341 }
30342
30343
30344 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30345 PyObject *resultobj = NULL;
30346 wxWindow *arg1 = (wxWindow *) 0 ;
30347 wxPoint *arg2 = 0 ;
30348 bool result;
30349 wxPoint temp2 ;
30350 PyObject * obj0 = 0 ;
30351 PyObject * obj1 = 0 ;
30352 char *kwnames[] = {
30353 (char *) "self",(char *) "pt", NULL
30354 };
30355
30356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
30357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30358 if (SWIG_arg_fail(1)) SWIG_fail;
30359 {
30360 arg2 = &temp2;
30361 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30362 }
30363 {
30364 PyThreadState* __tstate = wxPyBeginAllowThreads();
30365 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
30366
30367 wxPyEndAllowThreads(__tstate);
30368 if (PyErr_Occurred()) SWIG_fail;
30369 }
30370 {
30371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30372 }
30373 return resultobj;
30374 fail:
30375 return NULL;
30376 }
30377
30378
30379 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
30380 PyObject *resultobj = NULL;
30381 wxWindow *arg1 = (wxWindow *) 0 ;
30382 wxRect *arg2 = 0 ;
30383 bool result;
30384 wxRect temp2 ;
30385 PyObject * obj0 = 0 ;
30386 PyObject * obj1 = 0 ;
30387 char *kwnames[] = {
30388 (char *) "self",(char *) "rect", NULL
30389 };
30390
30391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
30392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30393 if (SWIG_arg_fail(1)) SWIG_fail;
30394 {
30395 arg2 = &temp2;
30396 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30397 }
30398 {
30399 PyThreadState* __tstate = wxPyBeginAllowThreads();
30400 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
30401
30402 wxPyEndAllowThreads(__tstate);
30403 if (PyErr_Occurred()) SWIG_fail;
30404 }
30405 {
30406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30407 }
30408 return resultobj;
30409 fail:
30410 return NULL;
30411 }
30412
30413
30414 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30415 PyObject *resultobj = NULL;
30416 wxWindow *arg1 = (wxWindow *) 0 ;
30417 wxVisualAttributes result;
30418 PyObject * obj0 = 0 ;
30419 char *kwnames[] = {
30420 (char *) "self", NULL
30421 };
30422
30423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
30424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30425 if (SWIG_arg_fail(1)) SWIG_fail;
30426 {
30427 PyThreadState* __tstate = wxPyBeginAllowThreads();
30428 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
30429
30430 wxPyEndAllowThreads(__tstate);
30431 if (PyErr_Occurred()) SWIG_fail;
30432 }
30433 {
30434 wxVisualAttributes * resultptr;
30435 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
30436 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30437 }
30438 return resultobj;
30439 fail:
30440 return NULL;
30441 }
30442
30443
30444 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30445 PyObject *resultobj = NULL;
30446 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
30447 wxVisualAttributes result;
30448 PyObject * obj0 = 0 ;
30449 char *kwnames[] = {
30450 (char *) "variant", NULL
30451 };
30452
30453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
30454 if (obj0) {
30455 {
30456 arg1 = static_cast<wxWindowVariant >(SWIG_As_int(obj0));
30457 if (SWIG_arg_fail(1)) SWIG_fail;
30458 }
30459 }
30460 {
30461 if (!wxPyCheckForApp()) SWIG_fail;
30462 PyThreadState* __tstate = wxPyBeginAllowThreads();
30463 result = wxWindow::GetClassDefaultAttributes(arg1);
30464
30465 wxPyEndAllowThreads(__tstate);
30466 if (PyErr_Occurred()) SWIG_fail;
30467 }
30468 {
30469 wxVisualAttributes * resultptr;
30470 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
30471 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30472 }
30473 return resultobj;
30474 fail:
30475 return NULL;
30476 }
30477
30478
30479 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30480 PyObject *resultobj = NULL;
30481 wxWindow *arg1 = (wxWindow *) 0 ;
30482 wxColour *arg2 = 0 ;
30483 bool result;
30484 wxColour temp2 ;
30485 PyObject * obj0 = 0 ;
30486 PyObject * obj1 = 0 ;
30487 char *kwnames[] = {
30488 (char *) "self",(char *) "colour", NULL
30489 };
30490
30491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30493 if (SWIG_arg_fail(1)) SWIG_fail;
30494 {
30495 arg2 = &temp2;
30496 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30497 }
30498 {
30499 PyThreadState* __tstate = wxPyBeginAllowThreads();
30500 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
30501
30502 wxPyEndAllowThreads(__tstate);
30503 if (PyErr_Occurred()) SWIG_fail;
30504 }
30505 {
30506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30507 }
30508 return resultobj;
30509 fail:
30510 return NULL;
30511 }
30512
30513
30514 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30515 PyObject *resultobj = NULL;
30516 wxWindow *arg1 = (wxWindow *) 0 ;
30517 wxColour *arg2 = 0 ;
30518 wxColour temp2 ;
30519 PyObject * obj0 = 0 ;
30520 PyObject * obj1 = 0 ;
30521 char *kwnames[] = {
30522 (char *) "self",(char *) "colour", NULL
30523 };
30524
30525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30527 if (SWIG_arg_fail(1)) SWIG_fail;
30528 {
30529 arg2 = &temp2;
30530 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30531 }
30532 {
30533 PyThreadState* __tstate = wxPyBeginAllowThreads();
30534 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
30535
30536 wxPyEndAllowThreads(__tstate);
30537 if (PyErr_Occurred()) SWIG_fail;
30538 }
30539 Py_INCREF(Py_None); resultobj = Py_None;
30540 return resultobj;
30541 fail:
30542 return NULL;
30543 }
30544
30545
30546 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30547 PyObject *resultobj = NULL;
30548 wxWindow *arg1 = (wxWindow *) 0 ;
30549 wxColour *arg2 = 0 ;
30550 bool result;
30551 wxColour temp2 ;
30552 PyObject * obj0 = 0 ;
30553 PyObject * obj1 = 0 ;
30554 char *kwnames[] = {
30555 (char *) "self",(char *) "colour", NULL
30556 };
30557
30558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30560 if (SWIG_arg_fail(1)) SWIG_fail;
30561 {
30562 arg2 = &temp2;
30563 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30564 }
30565 {
30566 PyThreadState* __tstate = wxPyBeginAllowThreads();
30567 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
30568
30569 wxPyEndAllowThreads(__tstate);
30570 if (PyErr_Occurred()) SWIG_fail;
30571 }
30572 {
30573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30574 }
30575 return resultobj;
30576 fail:
30577 return NULL;
30578 }
30579
30580
30581 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30582 PyObject *resultobj = NULL;
30583 wxWindow *arg1 = (wxWindow *) 0 ;
30584 wxColour *arg2 = 0 ;
30585 wxColour temp2 ;
30586 PyObject * obj0 = 0 ;
30587 PyObject * obj1 = 0 ;
30588 char *kwnames[] = {
30589 (char *) "self",(char *) "colour", NULL
30590 };
30591
30592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30594 if (SWIG_arg_fail(1)) SWIG_fail;
30595 {
30596 arg2 = &temp2;
30597 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30598 }
30599 {
30600 PyThreadState* __tstate = wxPyBeginAllowThreads();
30601 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
30602
30603 wxPyEndAllowThreads(__tstate);
30604 if (PyErr_Occurred()) SWIG_fail;
30605 }
30606 Py_INCREF(Py_None); resultobj = Py_None;
30607 return resultobj;
30608 fail:
30609 return NULL;
30610 }
30611
30612
30613 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30614 PyObject *resultobj = NULL;
30615 wxWindow *arg1 = (wxWindow *) 0 ;
30616 wxColour result;
30617 PyObject * obj0 = 0 ;
30618 char *kwnames[] = {
30619 (char *) "self", NULL
30620 };
30621
30622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
30623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30624 if (SWIG_arg_fail(1)) SWIG_fail;
30625 {
30626 PyThreadState* __tstate = wxPyBeginAllowThreads();
30627 result = ((wxWindow const *)arg1)->GetBackgroundColour();
30628
30629 wxPyEndAllowThreads(__tstate);
30630 if (PyErr_Occurred()) SWIG_fail;
30631 }
30632 {
30633 wxColour * resultptr;
30634 resultptr = new wxColour(static_cast<wxColour & >(result));
30635 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30636 }
30637 return resultobj;
30638 fail:
30639 return NULL;
30640 }
30641
30642
30643 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30644 PyObject *resultobj = NULL;
30645 wxWindow *arg1 = (wxWindow *) 0 ;
30646 wxColour result;
30647 PyObject * obj0 = 0 ;
30648 char *kwnames[] = {
30649 (char *) "self", NULL
30650 };
30651
30652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
30653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30654 if (SWIG_arg_fail(1)) SWIG_fail;
30655 {
30656 PyThreadState* __tstate = wxPyBeginAllowThreads();
30657 result = ((wxWindow const *)arg1)->GetForegroundColour();
30658
30659 wxPyEndAllowThreads(__tstate);
30660 if (PyErr_Occurred()) SWIG_fail;
30661 }
30662 {
30663 wxColour * resultptr;
30664 resultptr = new wxColour(static_cast<wxColour & >(result));
30665 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30666 }
30667 return resultobj;
30668 fail:
30669 return NULL;
30670 }
30671
30672
30673 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30674 PyObject *resultobj = NULL;
30675 wxWindow *arg1 = (wxWindow *) 0 ;
30676 bool result;
30677 PyObject * obj0 = 0 ;
30678 char *kwnames[] = {
30679 (char *) "self", NULL
30680 };
30681
30682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
30683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30684 if (SWIG_arg_fail(1)) SWIG_fail;
30685 {
30686 PyThreadState* __tstate = wxPyBeginAllowThreads();
30687 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
30688
30689 wxPyEndAllowThreads(__tstate);
30690 if (PyErr_Occurred()) SWIG_fail;
30691 }
30692 {
30693 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30694 }
30695 return resultobj;
30696 fail:
30697 return NULL;
30698 }
30699
30700
30701 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
30702 PyObject *resultobj = NULL;
30703 wxWindow *arg1 = (wxWindow *) 0 ;
30704 bool result;
30705 PyObject * obj0 = 0 ;
30706 char *kwnames[] = {
30707 (char *) "self", NULL
30708 };
30709
30710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
30711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30712 if (SWIG_arg_fail(1)) SWIG_fail;
30713 {
30714 PyThreadState* __tstate = wxPyBeginAllowThreads();
30715 result = (bool)((wxWindow const *)arg1)->UseBgCol();
30716
30717 wxPyEndAllowThreads(__tstate);
30718 if (PyErr_Occurred()) SWIG_fail;
30719 }
30720 {
30721 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30722 }
30723 return resultobj;
30724 fail:
30725 return NULL;
30726 }
30727
30728
30729 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30730 PyObject *resultobj = NULL;
30731 wxWindow *arg1 = (wxWindow *) 0 ;
30732 wxBackgroundStyle arg2 ;
30733 bool result;
30734 PyObject * obj0 = 0 ;
30735 PyObject * obj1 = 0 ;
30736 char *kwnames[] = {
30737 (char *) "self",(char *) "style", NULL
30738 };
30739
30740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
30741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30742 if (SWIG_arg_fail(1)) SWIG_fail;
30743 {
30744 arg2 = static_cast<wxBackgroundStyle >(SWIG_As_int(obj1));
30745 if (SWIG_arg_fail(2)) SWIG_fail;
30746 }
30747 {
30748 PyThreadState* __tstate = wxPyBeginAllowThreads();
30749 result = (bool)(arg1)->SetBackgroundStyle(arg2);
30750
30751 wxPyEndAllowThreads(__tstate);
30752 if (PyErr_Occurred()) SWIG_fail;
30753 }
30754 {
30755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30756 }
30757 return resultobj;
30758 fail:
30759 return NULL;
30760 }
30761
30762
30763 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30764 PyObject *resultobj = NULL;
30765 wxWindow *arg1 = (wxWindow *) 0 ;
30766 wxBackgroundStyle result;
30767 PyObject * obj0 = 0 ;
30768 char *kwnames[] = {
30769 (char *) "self", NULL
30770 };
30771
30772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
30773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30774 if (SWIG_arg_fail(1)) SWIG_fail;
30775 {
30776 PyThreadState* __tstate = wxPyBeginAllowThreads();
30777 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30778
30779 wxPyEndAllowThreads(__tstate);
30780 if (PyErr_Occurred()) SWIG_fail;
30781 }
30782 resultobj = SWIG_From_int((result));
30783 return resultobj;
30784 fail:
30785 return NULL;
30786 }
30787
30788
30789 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30790 PyObject *resultobj = NULL;
30791 wxWindow *arg1 = (wxWindow *) 0 ;
30792 bool result;
30793 PyObject * obj0 = 0 ;
30794 char *kwnames[] = {
30795 (char *) "self", NULL
30796 };
30797
30798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30800 if (SWIG_arg_fail(1)) SWIG_fail;
30801 {
30802 PyThreadState* __tstate = wxPyBeginAllowThreads();
30803 result = (bool)(arg1)->HasTransparentBackground();
30804
30805 wxPyEndAllowThreads(__tstate);
30806 if (PyErr_Occurred()) SWIG_fail;
30807 }
30808 {
30809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30810 }
30811 return resultobj;
30812 fail:
30813 return NULL;
30814 }
30815
30816
30817 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30818 PyObject *resultobj = NULL;
30819 wxWindow *arg1 = (wxWindow *) 0 ;
30820 wxCursor *arg2 = 0 ;
30821 bool result;
30822 PyObject * obj0 = 0 ;
30823 PyObject * obj1 = 0 ;
30824 char *kwnames[] = {
30825 (char *) "self",(char *) "cursor", NULL
30826 };
30827
30828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30830 if (SWIG_arg_fail(1)) SWIG_fail;
30831 {
30832 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30833 if (SWIG_arg_fail(2)) SWIG_fail;
30834 if (arg2 == NULL) {
30835 SWIG_null_ref("wxCursor");
30836 }
30837 if (SWIG_arg_fail(2)) SWIG_fail;
30838 }
30839 {
30840 PyThreadState* __tstate = wxPyBeginAllowThreads();
30841 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30842
30843 wxPyEndAllowThreads(__tstate);
30844 if (PyErr_Occurred()) SWIG_fail;
30845 }
30846 {
30847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30848 }
30849 return resultobj;
30850 fail:
30851 return NULL;
30852 }
30853
30854
30855 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30856 PyObject *resultobj = NULL;
30857 wxWindow *arg1 = (wxWindow *) 0 ;
30858 wxCursor result;
30859 PyObject * obj0 = 0 ;
30860 char *kwnames[] = {
30861 (char *) "self", NULL
30862 };
30863
30864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30866 if (SWIG_arg_fail(1)) SWIG_fail;
30867 {
30868 PyThreadState* __tstate = wxPyBeginAllowThreads();
30869 result = (arg1)->GetCursor();
30870
30871 wxPyEndAllowThreads(__tstate);
30872 if (PyErr_Occurred()) SWIG_fail;
30873 }
30874 {
30875 wxCursor * resultptr;
30876 resultptr = new wxCursor(static_cast<wxCursor & >(result));
30877 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30878 }
30879 return resultobj;
30880 fail:
30881 return NULL;
30882 }
30883
30884
30885 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30886 PyObject *resultobj = NULL;
30887 wxWindow *arg1 = (wxWindow *) 0 ;
30888 wxFont *arg2 = 0 ;
30889 bool result;
30890 PyObject * obj0 = 0 ;
30891 PyObject * obj1 = 0 ;
30892 char *kwnames[] = {
30893 (char *) "self",(char *) "font", NULL
30894 };
30895
30896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30898 if (SWIG_arg_fail(1)) SWIG_fail;
30899 {
30900 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30901 if (SWIG_arg_fail(2)) SWIG_fail;
30902 if (arg2 == NULL) {
30903 SWIG_null_ref("wxFont");
30904 }
30905 if (SWIG_arg_fail(2)) SWIG_fail;
30906 }
30907 {
30908 PyThreadState* __tstate = wxPyBeginAllowThreads();
30909 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30910
30911 wxPyEndAllowThreads(__tstate);
30912 if (PyErr_Occurred()) SWIG_fail;
30913 }
30914 {
30915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30916 }
30917 return resultobj;
30918 fail:
30919 return NULL;
30920 }
30921
30922
30923 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30924 PyObject *resultobj = NULL;
30925 wxWindow *arg1 = (wxWindow *) 0 ;
30926 wxFont *arg2 = 0 ;
30927 PyObject * obj0 = 0 ;
30928 PyObject * obj1 = 0 ;
30929 char *kwnames[] = {
30930 (char *) "self",(char *) "font", NULL
30931 };
30932
30933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30935 if (SWIG_arg_fail(1)) SWIG_fail;
30936 {
30937 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30938 if (SWIG_arg_fail(2)) SWIG_fail;
30939 if (arg2 == NULL) {
30940 SWIG_null_ref("wxFont");
30941 }
30942 if (SWIG_arg_fail(2)) SWIG_fail;
30943 }
30944 {
30945 PyThreadState* __tstate = wxPyBeginAllowThreads();
30946 (arg1)->SetOwnFont((wxFont const &)*arg2);
30947
30948 wxPyEndAllowThreads(__tstate);
30949 if (PyErr_Occurred()) SWIG_fail;
30950 }
30951 Py_INCREF(Py_None); resultobj = Py_None;
30952 return resultobj;
30953 fail:
30954 return NULL;
30955 }
30956
30957
30958 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30959 PyObject *resultobj = NULL;
30960 wxWindow *arg1 = (wxWindow *) 0 ;
30961 wxFont result;
30962 PyObject * obj0 = 0 ;
30963 char *kwnames[] = {
30964 (char *) "self", NULL
30965 };
30966
30967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30969 if (SWIG_arg_fail(1)) SWIG_fail;
30970 {
30971 PyThreadState* __tstate = wxPyBeginAllowThreads();
30972 result = (arg1)->GetFont();
30973
30974 wxPyEndAllowThreads(__tstate);
30975 if (PyErr_Occurred()) SWIG_fail;
30976 }
30977 {
30978 wxFont * resultptr;
30979 resultptr = new wxFont(static_cast<wxFont & >(result));
30980 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30981 }
30982 return resultobj;
30983 fail:
30984 return NULL;
30985 }
30986
30987
30988 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30989 PyObject *resultobj = NULL;
30990 wxWindow *arg1 = (wxWindow *) 0 ;
30991 wxCaret *arg2 = (wxCaret *) 0 ;
30992 PyObject * obj0 = 0 ;
30993 PyObject * obj1 = 0 ;
30994 char *kwnames[] = {
30995 (char *) "self",(char *) "caret", NULL
30996 };
30997
30998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31000 if (SWIG_arg_fail(1)) SWIG_fail;
31001 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31002 if (SWIG_arg_fail(2)) SWIG_fail;
31003 {
31004 PyThreadState* __tstate = wxPyBeginAllowThreads();
31005 (arg1)->SetCaret(arg2);
31006
31007 wxPyEndAllowThreads(__tstate);
31008 if (PyErr_Occurred()) SWIG_fail;
31009 }
31010 Py_INCREF(Py_None); resultobj = Py_None;
31011 return resultobj;
31012 fail:
31013 return NULL;
31014 }
31015
31016
31017 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
31018 PyObject *resultobj = NULL;
31019 wxWindow *arg1 = (wxWindow *) 0 ;
31020 wxCaret *result;
31021 PyObject * obj0 = 0 ;
31022 char *kwnames[] = {
31023 (char *) "self", NULL
31024 };
31025
31026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
31027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31028 if (SWIG_arg_fail(1)) SWIG_fail;
31029 {
31030 PyThreadState* __tstate = wxPyBeginAllowThreads();
31031 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
31032
31033 wxPyEndAllowThreads(__tstate);
31034 if (PyErr_Occurred()) SWIG_fail;
31035 }
31036 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
31037 return resultobj;
31038 fail:
31039 return NULL;
31040 }
31041
31042
31043 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
31044 PyObject *resultobj = NULL;
31045 wxWindow *arg1 = (wxWindow *) 0 ;
31046 int result;
31047 PyObject * obj0 = 0 ;
31048 char *kwnames[] = {
31049 (char *) "self", NULL
31050 };
31051
31052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
31053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31054 if (SWIG_arg_fail(1)) SWIG_fail;
31055 {
31056 PyThreadState* __tstate = wxPyBeginAllowThreads();
31057 result = (int)((wxWindow const *)arg1)->GetCharHeight();
31058
31059 wxPyEndAllowThreads(__tstate);
31060 if (PyErr_Occurred()) SWIG_fail;
31061 }
31062 {
31063 resultobj = SWIG_From_int(static_cast<int >(result));
31064 }
31065 return resultobj;
31066 fail:
31067 return NULL;
31068 }
31069
31070
31071 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
31072 PyObject *resultobj = NULL;
31073 wxWindow *arg1 = (wxWindow *) 0 ;
31074 int result;
31075 PyObject * obj0 = 0 ;
31076 char *kwnames[] = {
31077 (char *) "self", NULL
31078 };
31079
31080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
31081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31082 if (SWIG_arg_fail(1)) SWIG_fail;
31083 {
31084 PyThreadState* __tstate = wxPyBeginAllowThreads();
31085 result = (int)((wxWindow const *)arg1)->GetCharWidth();
31086
31087 wxPyEndAllowThreads(__tstate);
31088 if (PyErr_Occurred()) SWIG_fail;
31089 }
31090 {
31091 resultobj = SWIG_From_int(static_cast<int >(result));
31092 }
31093 return resultobj;
31094 fail:
31095 return NULL;
31096 }
31097
31098
31099 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
31100 PyObject *resultobj = NULL;
31101 wxWindow *arg1 = (wxWindow *) 0 ;
31102 wxString *arg2 = 0 ;
31103 int *arg3 = (int *) 0 ;
31104 int *arg4 = (int *) 0 ;
31105 bool temp2 = false ;
31106 int temp3 ;
31107 int res3 = 0 ;
31108 int temp4 ;
31109 int res4 = 0 ;
31110 PyObject * obj0 = 0 ;
31111 PyObject * obj1 = 0 ;
31112 char *kwnames[] = {
31113 (char *) "self",(char *) "string", NULL
31114 };
31115
31116 arg3 = &temp3; res3 = SWIG_NEWOBJ;
31117 arg4 = &temp4; res4 = SWIG_NEWOBJ;
31118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
31119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31120 if (SWIG_arg_fail(1)) SWIG_fail;
31121 {
31122 arg2 = wxString_in_helper(obj1);
31123 if (arg2 == NULL) SWIG_fail;
31124 temp2 = true;
31125 }
31126 {
31127 PyThreadState* __tstate = wxPyBeginAllowThreads();
31128 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
31129
31130 wxPyEndAllowThreads(__tstate);
31131 if (PyErr_Occurred()) SWIG_fail;
31132 }
31133 Py_INCREF(Py_None); resultobj = Py_None;
31134 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31135 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31136 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
31137 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
31138 {
31139 if (temp2)
31140 delete arg2;
31141 }
31142 return resultobj;
31143 fail:
31144 {
31145 if (temp2)
31146 delete arg2;
31147 }
31148 return NULL;
31149 }
31150
31151
31152 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
31153 PyObject *resultobj = NULL;
31154 wxWindow *arg1 = (wxWindow *) 0 ;
31155 wxString *arg2 = 0 ;
31156 int *arg3 = (int *) 0 ;
31157 int *arg4 = (int *) 0 ;
31158 int *arg5 = (int *) 0 ;
31159 int *arg6 = (int *) 0 ;
31160 wxFont *arg7 = (wxFont *) NULL ;
31161 bool temp2 = false ;
31162 int temp3 ;
31163 int res3 = 0 ;
31164 int temp4 ;
31165 int res4 = 0 ;
31166 int temp5 ;
31167 int res5 = 0 ;
31168 int temp6 ;
31169 int res6 = 0 ;
31170 PyObject * obj0 = 0 ;
31171 PyObject * obj1 = 0 ;
31172 PyObject * obj2 = 0 ;
31173 char *kwnames[] = {
31174 (char *) "self",(char *) "string",(char *) "font", NULL
31175 };
31176
31177 arg3 = &temp3; res3 = SWIG_NEWOBJ;
31178 arg4 = &temp4; res4 = SWIG_NEWOBJ;
31179 arg5 = &temp5; res5 = SWIG_NEWOBJ;
31180 arg6 = &temp6; res6 = SWIG_NEWOBJ;
31181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
31182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31183 if (SWIG_arg_fail(1)) SWIG_fail;
31184 {
31185 arg2 = wxString_in_helper(obj1);
31186 if (arg2 == NULL) SWIG_fail;
31187 temp2 = true;
31188 }
31189 if (obj2) {
31190 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
31191 if (SWIG_arg_fail(7)) SWIG_fail;
31192 }
31193 {
31194 PyThreadState* __tstate = wxPyBeginAllowThreads();
31195 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
31196
31197 wxPyEndAllowThreads(__tstate);
31198 if (PyErr_Occurred()) SWIG_fail;
31199 }
31200 Py_INCREF(Py_None); resultobj = Py_None;
31201 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31202 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31203 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
31204 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
31205 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
31206 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
31207 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
31208 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
31209 {
31210 if (temp2)
31211 delete arg2;
31212 }
31213 return resultobj;
31214 fail:
31215 {
31216 if (temp2)
31217 delete arg2;
31218 }
31219 return NULL;
31220 }
31221
31222
31223 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
31224 PyObject *resultobj = NULL;
31225 wxWindow *arg1 = (wxWindow *) 0 ;
31226 int *arg2 = (int *) 0 ;
31227 int *arg3 = (int *) 0 ;
31228 int temp2 ;
31229 int res2 = 0 ;
31230 int temp3 ;
31231 int res3 = 0 ;
31232 PyObject * obj0 = 0 ;
31233 PyObject * obj1 = 0 ;
31234 PyObject * obj2 = 0 ;
31235 char *kwnames[] = {
31236 (char *) "self",(char *) "x",(char *) "y", NULL
31237 };
31238
31239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31241 if (SWIG_arg_fail(1)) SWIG_fail;
31242 {
31243 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31244 temp2 = SWIG_As_int(obj1);
31245 if (SWIG_arg_fail(2)) SWIG_fail;
31246 arg2 = &temp2;
31247 res2 = SWIG_NEWOBJ;
31248 }
31249 }
31250 {
31251 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31252 temp3 = SWIG_As_int(obj2);
31253 if (SWIG_arg_fail(3)) SWIG_fail;
31254 arg3 = &temp3;
31255 res3 = SWIG_NEWOBJ;
31256 }
31257 }
31258 {
31259 PyThreadState* __tstate = wxPyBeginAllowThreads();
31260 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
31261
31262 wxPyEndAllowThreads(__tstate);
31263 if (PyErr_Occurred()) SWIG_fail;
31264 }
31265 Py_INCREF(Py_None); resultobj = Py_None;
31266 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31267 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31268 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31269 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31270 return resultobj;
31271 fail:
31272 return NULL;
31273 }
31274
31275
31276 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
31277 PyObject *resultobj = NULL;
31278 wxWindow *arg1 = (wxWindow *) 0 ;
31279 int *arg2 = (int *) 0 ;
31280 int *arg3 = (int *) 0 ;
31281 int temp2 ;
31282 int res2 = 0 ;
31283 int temp3 ;
31284 int res3 = 0 ;
31285 PyObject * obj0 = 0 ;
31286 PyObject * obj1 = 0 ;
31287 PyObject * obj2 = 0 ;
31288 char *kwnames[] = {
31289 (char *) "self",(char *) "x",(char *) "y", NULL
31290 };
31291
31292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31294 if (SWIG_arg_fail(1)) SWIG_fail;
31295 {
31296 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
31297 temp2 = SWIG_As_int(obj1);
31298 if (SWIG_arg_fail(2)) SWIG_fail;
31299 arg2 = &temp2;
31300 res2 = SWIG_NEWOBJ;
31301 }
31302 }
31303 {
31304 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
31305 temp3 = SWIG_As_int(obj2);
31306 if (SWIG_arg_fail(3)) SWIG_fail;
31307 arg3 = &temp3;
31308 res3 = SWIG_NEWOBJ;
31309 }
31310 }
31311 {
31312 PyThreadState* __tstate = wxPyBeginAllowThreads();
31313 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
31314
31315 wxPyEndAllowThreads(__tstate);
31316 if (PyErr_Occurred()) SWIG_fail;
31317 }
31318 Py_INCREF(Py_None); resultobj = Py_None;
31319 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31320 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31321 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31322 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31323 return resultobj;
31324 fail:
31325 return NULL;
31326 }
31327
31328
31329 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
31330 PyObject *resultobj = NULL;
31331 wxWindow *arg1 = (wxWindow *) 0 ;
31332 wxPoint *arg2 = 0 ;
31333 wxPoint result;
31334 wxPoint temp2 ;
31335 PyObject * obj0 = 0 ;
31336 PyObject * obj1 = 0 ;
31337 char *kwnames[] = {
31338 (char *) "self",(char *) "pt", NULL
31339 };
31340
31341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
31342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31343 if (SWIG_arg_fail(1)) SWIG_fail;
31344 {
31345 arg2 = &temp2;
31346 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31347 }
31348 {
31349 PyThreadState* __tstate = wxPyBeginAllowThreads();
31350 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
31351
31352 wxPyEndAllowThreads(__tstate);
31353 if (PyErr_Occurred()) SWIG_fail;
31354 }
31355 {
31356 wxPoint * resultptr;
31357 resultptr = new wxPoint(static_cast<wxPoint & >(result));
31358 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31359 }
31360 return resultobj;
31361 fail:
31362 return NULL;
31363 }
31364
31365
31366 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
31367 PyObject *resultobj = NULL;
31368 wxWindow *arg1 = (wxWindow *) 0 ;
31369 wxPoint *arg2 = 0 ;
31370 wxPoint result;
31371 wxPoint temp2 ;
31372 PyObject * obj0 = 0 ;
31373 PyObject * obj1 = 0 ;
31374 char *kwnames[] = {
31375 (char *) "self",(char *) "pt", NULL
31376 };
31377
31378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
31379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31380 if (SWIG_arg_fail(1)) SWIG_fail;
31381 {
31382 arg2 = &temp2;
31383 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31384 }
31385 {
31386 PyThreadState* __tstate = wxPyBeginAllowThreads();
31387 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
31388
31389 wxPyEndAllowThreads(__tstate);
31390 if (PyErr_Occurred()) SWIG_fail;
31391 }
31392 {
31393 wxPoint * resultptr;
31394 resultptr = new wxPoint(static_cast<wxPoint & >(result));
31395 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31396 }
31397 return resultobj;
31398 fail:
31399 return NULL;
31400 }
31401
31402
31403 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
31404 PyObject *resultobj = NULL;
31405 wxWindow *arg1 = (wxWindow *) 0 ;
31406 int arg2 ;
31407 int arg3 ;
31408 wxHitTest result;
31409 PyObject * obj0 = 0 ;
31410 PyObject * obj1 = 0 ;
31411 PyObject * obj2 = 0 ;
31412 char *kwnames[] = {
31413 (char *) "self",(char *) "x",(char *) "y", NULL
31414 };
31415
31416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31418 if (SWIG_arg_fail(1)) SWIG_fail;
31419 {
31420 arg2 = static_cast<int >(SWIG_As_int(obj1));
31421 if (SWIG_arg_fail(2)) SWIG_fail;
31422 }
31423 {
31424 arg3 = static_cast<int >(SWIG_As_int(obj2));
31425 if (SWIG_arg_fail(3)) SWIG_fail;
31426 }
31427 {
31428 PyThreadState* __tstate = wxPyBeginAllowThreads();
31429 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
31430
31431 wxPyEndAllowThreads(__tstate);
31432 if (PyErr_Occurred()) SWIG_fail;
31433 }
31434 resultobj = SWIG_From_int((result));
31435 return resultobj;
31436 fail:
31437 return NULL;
31438 }
31439
31440
31441 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
31442 PyObject *resultobj = NULL;
31443 wxWindow *arg1 = (wxWindow *) 0 ;
31444 wxPoint *arg2 = 0 ;
31445 wxHitTest result;
31446 wxPoint temp2 ;
31447 PyObject * obj0 = 0 ;
31448 PyObject * obj1 = 0 ;
31449 char *kwnames[] = {
31450 (char *) "self",(char *) "pt", NULL
31451 };
31452
31453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
31454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31455 if (SWIG_arg_fail(1)) SWIG_fail;
31456 {
31457 arg2 = &temp2;
31458 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31459 }
31460 {
31461 PyThreadState* __tstate = wxPyBeginAllowThreads();
31462 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
31463
31464 wxPyEndAllowThreads(__tstate);
31465 if (PyErr_Occurred()) SWIG_fail;
31466 }
31467 resultobj = SWIG_From_int((result));
31468 return resultobj;
31469 fail:
31470 return NULL;
31471 }
31472
31473
31474 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
31475 PyObject *resultobj = NULL;
31476 wxWindow *arg1 = (wxWindow *) 0 ;
31477 long arg2 ;
31478 wxBorder result;
31479 PyObject * obj0 = 0 ;
31480 PyObject * obj1 = 0 ;
31481
31482 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
31483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31484 if (SWIG_arg_fail(1)) SWIG_fail;
31485 {
31486 arg2 = static_cast<long >(SWIG_As_long(obj1));
31487 if (SWIG_arg_fail(2)) SWIG_fail;
31488 }
31489 {
31490 PyThreadState* __tstate = wxPyBeginAllowThreads();
31491 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
31492
31493 wxPyEndAllowThreads(__tstate);
31494 if (PyErr_Occurred()) SWIG_fail;
31495 }
31496 resultobj = SWIG_From_int((result));
31497 return resultobj;
31498 fail:
31499 return NULL;
31500 }
31501
31502
31503 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
31504 PyObject *resultobj = NULL;
31505 wxWindow *arg1 = (wxWindow *) 0 ;
31506 wxBorder result;
31507 PyObject * obj0 = 0 ;
31508
31509 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
31510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31511 if (SWIG_arg_fail(1)) SWIG_fail;
31512 {
31513 PyThreadState* __tstate = wxPyBeginAllowThreads();
31514 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
31515
31516 wxPyEndAllowThreads(__tstate);
31517 if (PyErr_Occurred()) SWIG_fail;
31518 }
31519 resultobj = SWIG_From_int((result));
31520 return resultobj;
31521 fail:
31522 return NULL;
31523 }
31524
31525
31526 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
31527 int argc;
31528 PyObject *argv[3];
31529 int ii;
31530
31531 argc = PyObject_Length(args);
31532 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
31533 argv[ii] = PyTuple_GetItem(args,ii);
31534 }
31535 if (argc == 1) {
31536 int _v;
31537 {
31538 void *ptr;
31539 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31540 _v = 0;
31541 PyErr_Clear();
31542 } else {
31543 _v = 1;
31544 }
31545 }
31546 if (_v) {
31547 return _wrap_Window_GetBorder__SWIG_1(self,args);
31548 }
31549 }
31550 if (argc == 2) {
31551 int _v;
31552 {
31553 void *ptr;
31554 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31555 _v = 0;
31556 PyErr_Clear();
31557 } else {
31558 _v = 1;
31559 }
31560 }
31561 if (_v) {
31562 _v = SWIG_Check_long(argv[1]);
31563 if (_v) {
31564 return _wrap_Window_GetBorder__SWIG_0(self,args);
31565 }
31566 }
31567 }
31568
31569 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
31570 return NULL;
31571 }
31572
31573
31574 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
31575 PyObject *resultobj = NULL;
31576 wxWindow *arg1 = (wxWindow *) 0 ;
31577 long arg2 = (long) wxUPDATE_UI_NONE ;
31578 PyObject * obj0 = 0 ;
31579 PyObject * obj1 = 0 ;
31580 char *kwnames[] = {
31581 (char *) "self",(char *) "flags", NULL
31582 };
31583
31584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
31585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31586 if (SWIG_arg_fail(1)) SWIG_fail;
31587 if (obj1) {
31588 {
31589 arg2 = static_cast<long >(SWIG_As_long(obj1));
31590 if (SWIG_arg_fail(2)) SWIG_fail;
31591 }
31592 }
31593 {
31594 PyThreadState* __tstate = wxPyBeginAllowThreads();
31595 (arg1)->UpdateWindowUI(arg2);
31596
31597 wxPyEndAllowThreads(__tstate);
31598 if (PyErr_Occurred()) SWIG_fail;
31599 }
31600 Py_INCREF(Py_None); resultobj = Py_None;
31601 return resultobj;
31602 fail:
31603 return NULL;
31604 }
31605
31606
31607 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
31608 PyObject *resultobj = NULL;
31609 wxWindow *arg1 = (wxWindow *) 0 ;
31610 wxMenu *arg2 = (wxMenu *) 0 ;
31611 int arg3 = (int) -1 ;
31612 int arg4 = (int) -1 ;
31613 bool result;
31614 PyObject * obj0 = 0 ;
31615 PyObject * obj1 = 0 ;
31616 PyObject * obj2 = 0 ;
31617 PyObject * obj3 = 0 ;
31618 char *kwnames[] = {
31619 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
31620 };
31621
31622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31624 if (SWIG_arg_fail(1)) SWIG_fail;
31625 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31626 if (SWIG_arg_fail(2)) SWIG_fail;
31627 if (obj2) {
31628 {
31629 arg3 = static_cast<int >(SWIG_As_int(obj2));
31630 if (SWIG_arg_fail(3)) SWIG_fail;
31631 }
31632 }
31633 if (obj3) {
31634 {
31635 arg4 = static_cast<int >(SWIG_As_int(obj3));
31636 if (SWIG_arg_fail(4)) SWIG_fail;
31637 }
31638 }
31639 {
31640 PyThreadState* __tstate = wxPyBeginAllowThreads();
31641 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
31642
31643 wxPyEndAllowThreads(__tstate);
31644 if (PyErr_Occurred()) SWIG_fail;
31645 }
31646 {
31647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31648 }
31649 return resultobj;
31650 fail:
31651 return NULL;
31652 }
31653
31654
31655 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
31656 PyObject *resultobj = NULL;
31657 wxWindow *arg1 = (wxWindow *) 0 ;
31658 wxMenu *arg2 = (wxMenu *) 0 ;
31659 wxPoint const &arg3_defvalue = wxDefaultPosition ;
31660 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
31661 bool result;
31662 wxPoint temp3 ;
31663 PyObject * obj0 = 0 ;
31664 PyObject * obj1 = 0 ;
31665 PyObject * obj2 = 0 ;
31666 char *kwnames[] = {
31667 (char *) "self",(char *) "menu",(char *) "pos", NULL
31668 };
31669
31670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
31671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31672 if (SWIG_arg_fail(1)) SWIG_fail;
31673 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31674 if (SWIG_arg_fail(2)) SWIG_fail;
31675 if (obj2) {
31676 {
31677 arg3 = &temp3;
31678 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
31679 }
31680 }
31681 {
31682 PyThreadState* __tstate = wxPyBeginAllowThreads();
31683 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
31684
31685 wxPyEndAllowThreads(__tstate);
31686 if (PyErr_Occurred()) SWIG_fail;
31687 }
31688 {
31689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31690 }
31691 return resultobj;
31692 fail:
31693 return NULL;
31694 }
31695
31696
31697 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31698 PyObject *resultobj = NULL;
31699 wxWindow *arg1 = (wxWindow *) 0 ;
31700 long result;
31701 PyObject * obj0 = 0 ;
31702 char *kwnames[] = {
31703 (char *) "self", NULL
31704 };
31705
31706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
31707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31708 if (SWIG_arg_fail(1)) SWIG_fail;
31709 {
31710 PyThreadState* __tstate = wxPyBeginAllowThreads();
31711 result = (long)wxWindow_GetHandle(arg1);
31712
31713 wxPyEndAllowThreads(__tstate);
31714 if (PyErr_Occurred()) SWIG_fail;
31715 }
31716 {
31717 resultobj = SWIG_From_long(static_cast<long >(result));
31718 }
31719 return resultobj;
31720 fail:
31721 return NULL;
31722 }
31723
31724
31725 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31726 PyObject *resultobj = NULL;
31727 wxWindow *arg1 = (wxWindow *) 0 ;
31728 long arg2 ;
31729 PyObject * obj0 = 0 ;
31730 PyObject * obj1 = 0 ;
31731 char *kwnames[] = {
31732 (char *) "self",(char *) "handle", NULL
31733 };
31734
31735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
31736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31737 if (SWIG_arg_fail(1)) SWIG_fail;
31738 {
31739 arg2 = static_cast<long >(SWIG_As_long(obj1));
31740 if (SWIG_arg_fail(2)) SWIG_fail;
31741 }
31742 {
31743 PyThreadState* __tstate = wxPyBeginAllowThreads();
31744 wxWindow_AssociateHandle(arg1,arg2);
31745
31746 wxPyEndAllowThreads(__tstate);
31747 if (PyErr_Occurred()) SWIG_fail;
31748 }
31749 Py_INCREF(Py_None); resultobj = Py_None;
31750 return resultobj;
31751 fail:
31752 return NULL;
31753 }
31754
31755
31756 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31757 PyObject *resultobj = NULL;
31758 wxWindow *arg1 = (wxWindow *) 0 ;
31759 PyObject * obj0 = 0 ;
31760 char *kwnames[] = {
31761 (char *) "self", NULL
31762 };
31763
31764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
31765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31766 if (SWIG_arg_fail(1)) SWIG_fail;
31767 {
31768 PyThreadState* __tstate = wxPyBeginAllowThreads();
31769 (arg1)->DissociateHandle();
31770
31771 wxPyEndAllowThreads(__tstate);
31772 if (PyErr_Occurred()) SWIG_fail;
31773 }
31774 Py_INCREF(Py_None); resultobj = Py_None;
31775 return resultobj;
31776 fail:
31777 return NULL;
31778 }
31779
31780
31781 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
31782 PyObject *resultobj = NULL;
31783 wxWindow *arg1 = (wxWindow *) 0 ;
31784 wxPaintEvent *arg2 = 0 ;
31785 PyObject * obj0 = 0 ;
31786 PyObject * obj1 = 0 ;
31787 char *kwnames[] = {
31788 (char *) "self",(char *) "event", NULL
31789 };
31790
31791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
31792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31793 if (SWIG_arg_fail(1)) SWIG_fail;
31794 {
31795 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
31796 if (SWIG_arg_fail(2)) SWIG_fail;
31797 if (arg2 == NULL) {
31798 SWIG_null_ref("wxPaintEvent");
31799 }
31800 if (SWIG_arg_fail(2)) SWIG_fail;
31801 }
31802 {
31803 PyThreadState* __tstate = wxPyBeginAllowThreads();
31804 (arg1)->OnPaint(*arg2);
31805
31806 wxPyEndAllowThreads(__tstate);
31807 if (PyErr_Occurred()) SWIG_fail;
31808 }
31809 Py_INCREF(Py_None); resultobj = Py_None;
31810 return resultobj;
31811 fail:
31812 return NULL;
31813 }
31814
31815
31816 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31817 PyObject *resultobj = NULL;
31818 wxWindow *arg1 = (wxWindow *) 0 ;
31819 int arg2 ;
31820 bool result;
31821 PyObject * obj0 = 0 ;
31822 PyObject * obj1 = 0 ;
31823 char *kwnames[] = {
31824 (char *) "self",(char *) "orient", NULL
31825 };
31826
31827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31829 if (SWIG_arg_fail(1)) SWIG_fail;
31830 {
31831 arg2 = static_cast<int >(SWIG_As_int(obj1));
31832 if (SWIG_arg_fail(2)) SWIG_fail;
31833 }
31834 {
31835 PyThreadState* __tstate = wxPyBeginAllowThreads();
31836 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31837
31838 wxPyEndAllowThreads(__tstate);
31839 if (PyErr_Occurred()) SWIG_fail;
31840 }
31841 {
31842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31843 }
31844 return resultobj;
31845 fail:
31846 return NULL;
31847 }
31848
31849
31850 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31851 PyObject *resultobj = NULL;
31852 wxWindow *arg1 = (wxWindow *) 0 ;
31853 int arg2 ;
31854 int arg3 ;
31855 int arg4 ;
31856 int arg5 ;
31857 bool arg6 = (bool) true ;
31858 PyObject * obj0 = 0 ;
31859 PyObject * obj1 = 0 ;
31860 PyObject * obj2 = 0 ;
31861 PyObject * obj3 = 0 ;
31862 PyObject * obj4 = 0 ;
31863 PyObject * obj5 = 0 ;
31864 char *kwnames[] = {
31865 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31866 };
31867
31868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31870 if (SWIG_arg_fail(1)) SWIG_fail;
31871 {
31872 arg2 = static_cast<int >(SWIG_As_int(obj1));
31873 if (SWIG_arg_fail(2)) SWIG_fail;
31874 }
31875 {
31876 arg3 = static_cast<int >(SWIG_As_int(obj2));
31877 if (SWIG_arg_fail(3)) SWIG_fail;
31878 }
31879 {
31880 arg4 = static_cast<int >(SWIG_As_int(obj3));
31881 if (SWIG_arg_fail(4)) SWIG_fail;
31882 }
31883 {
31884 arg5 = static_cast<int >(SWIG_As_int(obj4));
31885 if (SWIG_arg_fail(5)) SWIG_fail;
31886 }
31887 if (obj5) {
31888 {
31889 arg6 = static_cast<bool >(SWIG_As_bool(obj5));
31890 if (SWIG_arg_fail(6)) SWIG_fail;
31891 }
31892 }
31893 {
31894 PyThreadState* __tstate = wxPyBeginAllowThreads();
31895 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31896
31897 wxPyEndAllowThreads(__tstate);
31898 if (PyErr_Occurred()) SWIG_fail;
31899 }
31900 Py_INCREF(Py_None); resultobj = Py_None;
31901 return resultobj;
31902 fail:
31903 return NULL;
31904 }
31905
31906
31907 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31908 PyObject *resultobj = NULL;
31909 wxWindow *arg1 = (wxWindow *) 0 ;
31910 int arg2 ;
31911 int arg3 ;
31912 bool arg4 = (bool) true ;
31913 PyObject * obj0 = 0 ;
31914 PyObject * obj1 = 0 ;
31915 PyObject * obj2 = 0 ;
31916 PyObject * obj3 = 0 ;
31917 char *kwnames[] = {
31918 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31919 };
31920
31921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31923 if (SWIG_arg_fail(1)) SWIG_fail;
31924 {
31925 arg2 = static_cast<int >(SWIG_As_int(obj1));
31926 if (SWIG_arg_fail(2)) SWIG_fail;
31927 }
31928 {
31929 arg3 = static_cast<int >(SWIG_As_int(obj2));
31930 if (SWIG_arg_fail(3)) SWIG_fail;
31931 }
31932 if (obj3) {
31933 {
31934 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
31935 if (SWIG_arg_fail(4)) SWIG_fail;
31936 }
31937 }
31938 {
31939 PyThreadState* __tstate = wxPyBeginAllowThreads();
31940 (arg1)->SetScrollPos(arg2,arg3,arg4);
31941
31942 wxPyEndAllowThreads(__tstate);
31943 if (PyErr_Occurred()) SWIG_fail;
31944 }
31945 Py_INCREF(Py_None); resultobj = Py_None;
31946 return resultobj;
31947 fail:
31948 return NULL;
31949 }
31950
31951
31952 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31953 PyObject *resultobj = NULL;
31954 wxWindow *arg1 = (wxWindow *) 0 ;
31955 int arg2 ;
31956 int result;
31957 PyObject * obj0 = 0 ;
31958 PyObject * obj1 = 0 ;
31959 char *kwnames[] = {
31960 (char *) "self",(char *) "orientation", NULL
31961 };
31962
31963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31965 if (SWIG_arg_fail(1)) SWIG_fail;
31966 {
31967 arg2 = static_cast<int >(SWIG_As_int(obj1));
31968 if (SWIG_arg_fail(2)) SWIG_fail;
31969 }
31970 {
31971 PyThreadState* __tstate = wxPyBeginAllowThreads();
31972 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31973
31974 wxPyEndAllowThreads(__tstate);
31975 if (PyErr_Occurred()) SWIG_fail;
31976 }
31977 {
31978 resultobj = SWIG_From_int(static_cast<int >(result));
31979 }
31980 return resultobj;
31981 fail:
31982 return NULL;
31983 }
31984
31985
31986 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31987 PyObject *resultobj = NULL;
31988 wxWindow *arg1 = (wxWindow *) 0 ;
31989 int arg2 ;
31990 int result;
31991 PyObject * obj0 = 0 ;
31992 PyObject * obj1 = 0 ;
31993 char *kwnames[] = {
31994 (char *) "self",(char *) "orientation", NULL
31995 };
31996
31997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31999 if (SWIG_arg_fail(1)) SWIG_fail;
32000 {
32001 arg2 = static_cast<int >(SWIG_As_int(obj1));
32002 if (SWIG_arg_fail(2)) SWIG_fail;
32003 }
32004 {
32005 PyThreadState* __tstate = wxPyBeginAllowThreads();
32006 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
32007
32008 wxPyEndAllowThreads(__tstate);
32009 if (PyErr_Occurred()) SWIG_fail;
32010 }
32011 {
32012 resultobj = SWIG_From_int(static_cast<int >(result));
32013 }
32014 return resultobj;
32015 fail:
32016 return NULL;
32017 }
32018
32019
32020 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
32021 PyObject *resultobj = NULL;
32022 wxWindow *arg1 = (wxWindow *) 0 ;
32023 int arg2 ;
32024 int result;
32025 PyObject * obj0 = 0 ;
32026 PyObject * obj1 = 0 ;
32027 char *kwnames[] = {
32028 (char *) "self",(char *) "orientation", NULL
32029 };
32030
32031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
32032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32033 if (SWIG_arg_fail(1)) SWIG_fail;
32034 {
32035 arg2 = static_cast<int >(SWIG_As_int(obj1));
32036 if (SWIG_arg_fail(2)) SWIG_fail;
32037 }
32038 {
32039 PyThreadState* __tstate = wxPyBeginAllowThreads();
32040 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
32041
32042 wxPyEndAllowThreads(__tstate);
32043 if (PyErr_Occurred()) SWIG_fail;
32044 }
32045 {
32046 resultobj = SWIG_From_int(static_cast<int >(result));
32047 }
32048 return resultobj;
32049 fail:
32050 return NULL;
32051 }
32052
32053
32054 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32055 PyObject *resultobj = NULL;
32056 wxWindow *arg1 = (wxWindow *) 0 ;
32057 int arg2 ;
32058 int arg3 ;
32059 wxRect *arg4 = (wxRect *) NULL ;
32060 PyObject * obj0 = 0 ;
32061 PyObject * obj1 = 0 ;
32062 PyObject * obj2 = 0 ;
32063 PyObject * obj3 = 0 ;
32064 char *kwnames[] = {
32065 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
32066 };
32067
32068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32070 if (SWIG_arg_fail(1)) SWIG_fail;
32071 {
32072 arg2 = static_cast<int >(SWIG_As_int(obj1));
32073 if (SWIG_arg_fail(2)) SWIG_fail;
32074 }
32075 {
32076 arg3 = static_cast<int >(SWIG_As_int(obj2));
32077 if (SWIG_arg_fail(3)) SWIG_fail;
32078 }
32079 if (obj3) {
32080 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
32081 if (SWIG_arg_fail(4)) SWIG_fail;
32082 }
32083 {
32084 PyThreadState* __tstate = wxPyBeginAllowThreads();
32085 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
32086
32087 wxPyEndAllowThreads(__tstate);
32088 if (PyErr_Occurred()) SWIG_fail;
32089 }
32090 Py_INCREF(Py_None); resultobj = Py_None;
32091 return resultobj;
32092 fail:
32093 return NULL;
32094 }
32095
32096
32097 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
32098 PyObject *resultobj = NULL;
32099 wxWindow *arg1 = (wxWindow *) 0 ;
32100 int arg2 ;
32101 bool result;
32102 PyObject * obj0 = 0 ;
32103 PyObject * obj1 = 0 ;
32104 char *kwnames[] = {
32105 (char *) "self",(char *) "lines", NULL
32106 };
32107
32108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
32109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32110 if (SWIG_arg_fail(1)) SWIG_fail;
32111 {
32112 arg2 = static_cast<int >(SWIG_As_int(obj1));
32113 if (SWIG_arg_fail(2)) SWIG_fail;
32114 }
32115 {
32116 PyThreadState* __tstate = wxPyBeginAllowThreads();
32117 result = (bool)(arg1)->ScrollLines(arg2);
32118
32119 wxPyEndAllowThreads(__tstate);
32120 if (PyErr_Occurred()) SWIG_fail;
32121 }
32122 {
32123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32124 }
32125 return resultobj;
32126 fail:
32127 return NULL;
32128 }
32129
32130
32131 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
32132 PyObject *resultobj = NULL;
32133 wxWindow *arg1 = (wxWindow *) 0 ;
32134 int arg2 ;
32135 bool result;
32136 PyObject * obj0 = 0 ;
32137 PyObject * obj1 = 0 ;
32138 char *kwnames[] = {
32139 (char *) "self",(char *) "pages", NULL
32140 };
32141
32142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
32143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32144 if (SWIG_arg_fail(1)) SWIG_fail;
32145 {
32146 arg2 = static_cast<int >(SWIG_As_int(obj1));
32147 if (SWIG_arg_fail(2)) SWIG_fail;
32148 }
32149 {
32150 PyThreadState* __tstate = wxPyBeginAllowThreads();
32151 result = (bool)(arg1)->ScrollPages(arg2);
32152
32153 wxPyEndAllowThreads(__tstate);
32154 if (PyErr_Occurred()) SWIG_fail;
32155 }
32156 {
32157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32158 }
32159 return resultobj;
32160 fail:
32161 return NULL;
32162 }
32163
32164
32165 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
32166 PyObject *resultobj = NULL;
32167 wxWindow *arg1 = (wxWindow *) 0 ;
32168 bool result;
32169 PyObject * obj0 = 0 ;
32170 char *kwnames[] = {
32171 (char *) "self", NULL
32172 };
32173
32174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
32175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32176 if (SWIG_arg_fail(1)) SWIG_fail;
32177 {
32178 PyThreadState* __tstate = wxPyBeginAllowThreads();
32179 result = (bool)(arg1)->LineUp();
32180
32181 wxPyEndAllowThreads(__tstate);
32182 if (PyErr_Occurred()) SWIG_fail;
32183 }
32184 {
32185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32186 }
32187 return resultobj;
32188 fail:
32189 return NULL;
32190 }
32191
32192
32193 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
32194 PyObject *resultobj = NULL;
32195 wxWindow *arg1 = (wxWindow *) 0 ;
32196 bool result;
32197 PyObject * obj0 = 0 ;
32198 char *kwnames[] = {
32199 (char *) "self", NULL
32200 };
32201
32202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
32203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32204 if (SWIG_arg_fail(1)) SWIG_fail;
32205 {
32206 PyThreadState* __tstate = wxPyBeginAllowThreads();
32207 result = (bool)(arg1)->LineDown();
32208
32209 wxPyEndAllowThreads(__tstate);
32210 if (PyErr_Occurred()) SWIG_fail;
32211 }
32212 {
32213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32214 }
32215 return resultobj;
32216 fail:
32217 return NULL;
32218 }
32219
32220
32221 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
32222 PyObject *resultobj = NULL;
32223 wxWindow *arg1 = (wxWindow *) 0 ;
32224 bool result;
32225 PyObject * obj0 = 0 ;
32226 char *kwnames[] = {
32227 (char *) "self", NULL
32228 };
32229
32230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
32231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32232 if (SWIG_arg_fail(1)) SWIG_fail;
32233 {
32234 PyThreadState* __tstate = wxPyBeginAllowThreads();
32235 result = (bool)(arg1)->PageUp();
32236
32237 wxPyEndAllowThreads(__tstate);
32238 if (PyErr_Occurred()) SWIG_fail;
32239 }
32240 {
32241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32242 }
32243 return resultobj;
32244 fail:
32245 return NULL;
32246 }
32247
32248
32249 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
32250 PyObject *resultobj = NULL;
32251 wxWindow *arg1 = (wxWindow *) 0 ;
32252 bool result;
32253 PyObject * obj0 = 0 ;
32254 char *kwnames[] = {
32255 (char *) "self", NULL
32256 };
32257
32258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
32259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32260 if (SWIG_arg_fail(1)) SWIG_fail;
32261 {
32262 PyThreadState* __tstate = wxPyBeginAllowThreads();
32263 result = (bool)(arg1)->PageDown();
32264
32265 wxPyEndAllowThreads(__tstate);
32266 if (PyErr_Occurred()) SWIG_fail;
32267 }
32268 {
32269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32270 }
32271 return resultobj;
32272 fail:
32273 return NULL;
32274 }
32275
32276
32277 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32278 PyObject *resultobj = NULL;
32279 wxWindow *arg1 = (wxWindow *) 0 ;
32280 wxString *arg2 = 0 ;
32281 bool temp2 = false ;
32282 PyObject * obj0 = 0 ;
32283 PyObject * obj1 = 0 ;
32284 char *kwnames[] = {
32285 (char *) "self",(char *) "text", NULL
32286 };
32287
32288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
32289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32290 if (SWIG_arg_fail(1)) SWIG_fail;
32291 {
32292 arg2 = wxString_in_helper(obj1);
32293 if (arg2 == NULL) SWIG_fail;
32294 temp2 = true;
32295 }
32296 {
32297 PyThreadState* __tstate = wxPyBeginAllowThreads();
32298 (arg1)->SetHelpText((wxString const &)*arg2);
32299
32300 wxPyEndAllowThreads(__tstate);
32301 if (PyErr_Occurred()) SWIG_fail;
32302 }
32303 Py_INCREF(Py_None); resultobj = Py_None;
32304 {
32305 if (temp2)
32306 delete arg2;
32307 }
32308 return resultobj;
32309 fail:
32310 {
32311 if (temp2)
32312 delete arg2;
32313 }
32314 return NULL;
32315 }
32316
32317
32318 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
32319 PyObject *resultobj = NULL;
32320 wxWindow *arg1 = (wxWindow *) 0 ;
32321 wxString *arg2 = 0 ;
32322 bool temp2 = false ;
32323 PyObject * obj0 = 0 ;
32324 PyObject * obj1 = 0 ;
32325 char *kwnames[] = {
32326 (char *) "self",(char *) "text", NULL
32327 };
32328
32329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
32330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32331 if (SWIG_arg_fail(1)) SWIG_fail;
32332 {
32333 arg2 = wxString_in_helper(obj1);
32334 if (arg2 == NULL) SWIG_fail;
32335 temp2 = true;
32336 }
32337 {
32338 PyThreadState* __tstate = wxPyBeginAllowThreads();
32339 (arg1)->SetHelpTextForId((wxString const &)*arg2);
32340
32341 wxPyEndAllowThreads(__tstate);
32342 if (PyErr_Occurred()) SWIG_fail;
32343 }
32344 Py_INCREF(Py_None); resultobj = Py_None;
32345 {
32346 if (temp2)
32347 delete arg2;
32348 }
32349 return resultobj;
32350 fail:
32351 {
32352 if (temp2)
32353 delete arg2;
32354 }
32355 return NULL;
32356 }
32357
32358
32359 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32360 PyObject *resultobj = NULL;
32361 wxWindow *arg1 = (wxWindow *) 0 ;
32362 wxString result;
32363 PyObject * obj0 = 0 ;
32364 char *kwnames[] = {
32365 (char *) "self", NULL
32366 };
32367
32368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
32369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32370 if (SWIG_arg_fail(1)) SWIG_fail;
32371 {
32372 PyThreadState* __tstate = wxPyBeginAllowThreads();
32373 result = ((wxWindow const *)arg1)->GetHelpText();
32374
32375 wxPyEndAllowThreads(__tstate);
32376 if (PyErr_Occurred()) SWIG_fail;
32377 }
32378 {
32379 #if wxUSE_UNICODE
32380 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32381 #else
32382 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32383 #endif
32384 }
32385 return resultobj;
32386 fail:
32387 return NULL;
32388 }
32389
32390
32391 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
32392 PyObject *resultobj = NULL;
32393 wxWindow *arg1 = (wxWindow *) 0 ;
32394 wxString *arg2 = 0 ;
32395 bool temp2 = false ;
32396 PyObject * obj0 = 0 ;
32397 PyObject * obj1 = 0 ;
32398 char *kwnames[] = {
32399 (char *) "self",(char *) "tip", NULL
32400 };
32401
32402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
32403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32404 if (SWIG_arg_fail(1)) SWIG_fail;
32405 {
32406 arg2 = wxString_in_helper(obj1);
32407 if (arg2 == NULL) SWIG_fail;
32408 temp2 = true;
32409 }
32410 {
32411 PyThreadState* __tstate = wxPyBeginAllowThreads();
32412 (arg1)->SetToolTip((wxString const &)*arg2);
32413
32414 wxPyEndAllowThreads(__tstate);
32415 if (PyErr_Occurred()) SWIG_fail;
32416 }
32417 Py_INCREF(Py_None); resultobj = Py_None;
32418 {
32419 if (temp2)
32420 delete arg2;
32421 }
32422 return resultobj;
32423 fail:
32424 {
32425 if (temp2)
32426 delete arg2;
32427 }
32428 return NULL;
32429 }
32430
32431
32432 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32433 PyObject *resultobj = NULL;
32434 wxWindow *arg1 = (wxWindow *) 0 ;
32435 wxToolTip *arg2 = (wxToolTip *) 0 ;
32436 PyObject * obj0 = 0 ;
32437 PyObject * obj1 = 0 ;
32438 char *kwnames[] = {
32439 (char *) "self",(char *) "tip", NULL
32440 };
32441
32442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
32443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32444 if (SWIG_arg_fail(1)) SWIG_fail;
32445 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32446 if (SWIG_arg_fail(2)) SWIG_fail;
32447 {
32448 PyThreadState* __tstate = wxPyBeginAllowThreads();
32449 (arg1)->SetToolTip(arg2);
32450
32451 wxPyEndAllowThreads(__tstate);
32452 if (PyErr_Occurred()) SWIG_fail;
32453 }
32454 Py_INCREF(Py_None); resultobj = Py_None;
32455 return resultobj;
32456 fail:
32457 return NULL;
32458 }
32459
32460
32461 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32462 PyObject *resultobj = NULL;
32463 wxWindow *arg1 = (wxWindow *) 0 ;
32464 wxToolTip *result;
32465 PyObject * obj0 = 0 ;
32466 char *kwnames[] = {
32467 (char *) "self", NULL
32468 };
32469
32470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
32471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32472 if (SWIG_arg_fail(1)) SWIG_fail;
32473 {
32474 PyThreadState* __tstate = wxPyBeginAllowThreads();
32475 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
32476
32477 wxPyEndAllowThreads(__tstate);
32478 if (PyErr_Occurred()) SWIG_fail;
32479 }
32480 {
32481 resultobj = wxPyMake_wxObject(result, (bool)0);
32482 }
32483 return resultobj;
32484 fail:
32485 return NULL;
32486 }
32487
32488
32489 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32490 PyObject *resultobj = NULL;
32491 wxWindow *arg1 = (wxWindow *) 0 ;
32492 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
32493 PyObject * obj0 = 0 ;
32494 PyObject * obj1 = 0 ;
32495 char *kwnames[] = {
32496 (char *) "self",(char *) "dropTarget", NULL
32497 };
32498
32499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
32500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32501 if (SWIG_arg_fail(1)) SWIG_fail;
32502 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32503 if (SWIG_arg_fail(2)) SWIG_fail;
32504 {
32505 PyThreadState* __tstate = wxPyBeginAllowThreads();
32506 (arg1)->SetDropTarget(arg2);
32507
32508 wxPyEndAllowThreads(__tstate);
32509 if (PyErr_Occurred()) SWIG_fail;
32510 }
32511 Py_INCREF(Py_None); resultobj = Py_None;
32512 return resultobj;
32513 fail:
32514 return NULL;
32515 }
32516
32517
32518 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32519 PyObject *resultobj = NULL;
32520 wxWindow *arg1 = (wxWindow *) 0 ;
32521 wxPyDropTarget *result;
32522 PyObject * obj0 = 0 ;
32523 char *kwnames[] = {
32524 (char *) "self", NULL
32525 };
32526
32527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
32528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32529 if (SWIG_arg_fail(1)) SWIG_fail;
32530 {
32531 PyThreadState* __tstate = wxPyBeginAllowThreads();
32532 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
32533
32534 wxPyEndAllowThreads(__tstate);
32535 if (PyErr_Occurred()) SWIG_fail;
32536 }
32537 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
32538 return resultobj;
32539 fail:
32540 return NULL;
32541 }
32542
32543
32544 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
32545 PyObject *resultobj = NULL;
32546 wxWindow *arg1 = (wxWindow *) 0 ;
32547 bool arg2 ;
32548 PyObject * obj0 = 0 ;
32549 PyObject * obj1 = 0 ;
32550 char *kwnames[] = {
32551 (char *) "self",(char *) "accept", NULL
32552 };
32553
32554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
32555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32556 if (SWIG_arg_fail(1)) SWIG_fail;
32557 {
32558 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
32559 if (SWIG_arg_fail(2)) SWIG_fail;
32560 }
32561 {
32562 PyThreadState* __tstate = wxPyBeginAllowThreads();
32563 (arg1)->DragAcceptFiles(arg2);
32564
32565 wxPyEndAllowThreads(__tstate);
32566 if (PyErr_Occurred()) SWIG_fail;
32567 }
32568 Py_INCREF(Py_None); resultobj = Py_None;
32569 return resultobj;
32570 fail:
32571 return NULL;
32572 }
32573
32574
32575 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32576 PyObject *resultobj = NULL;
32577 wxWindow *arg1 = (wxWindow *) 0 ;
32578 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
32579 PyObject * obj0 = 0 ;
32580 PyObject * obj1 = 0 ;
32581 char *kwnames[] = {
32582 (char *) "self",(char *) "constraints", NULL
32583 };
32584
32585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
32586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32587 if (SWIG_arg_fail(1)) SWIG_fail;
32588 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
32589 if (SWIG_arg_fail(2)) SWIG_fail;
32590 {
32591 PyThreadState* __tstate = wxPyBeginAllowThreads();
32592 (arg1)->SetConstraints(arg2);
32593
32594 wxPyEndAllowThreads(__tstate);
32595 if (PyErr_Occurred()) SWIG_fail;
32596 }
32597 Py_INCREF(Py_None); resultobj = Py_None;
32598 return resultobj;
32599 fail:
32600 return NULL;
32601 }
32602
32603
32604 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32605 PyObject *resultobj = NULL;
32606 wxWindow *arg1 = (wxWindow *) 0 ;
32607 wxLayoutConstraints *result;
32608 PyObject * obj0 = 0 ;
32609 char *kwnames[] = {
32610 (char *) "self", NULL
32611 };
32612
32613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
32614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32615 if (SWIG_arg_fail(1)) SWIG_fail;
32616 {
32617 PyThreadState* __tstate = wxPyBeginAllowThreads();
32618 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
32619
32620 wxPyEndAllowThreads(__tstate);
32621 if (PyErr_Occurred()) SWIG_fail;
32622 }
32623 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
32624 return resultobj;
32625 fail:
32626 return NULL;
32627 }
32628
32629
32630 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32631 PyObject *resultobj = NULL;
32632 wxWindow *arg1 = (wxWindow *) 0 ;
32633 bool arg2 ;
32634 PyObject * obj0 = 0 ;
32635 PyObject * obj1 = 0 ;
32636 char *kwnames[] = {
32637 (char *) "self",(char *) "autoLayout", NULL
32638 };
32639
32640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
32641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32642 if (SWIG_arg_fail(1)) SWIG_fail;
32643 {
32644 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
32645 if (SWIG_arg_fail(2)) SWIG_fail;
32646 }
32647 {
32648 PyThreadState* __tstate = wxPyBeginAllowThreads();
32649 (arg1)->SetAutoLayout(arg2);
32650
32651 wxPyEndAllowThreads(__tstate);
32652 if (PyErr_Occurred()) SWIG_fail;
32653 }
32654 Py_INCREF(Py_None); resultobj = Py_None;
32655 return resultobj;
32656 fail:
32657 return NULL;
32658 }
32659
32660
32661 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32662 PyObject *resultobj = NULL;
32663 wxWindow *arg1 = (wxWindow *) 0 ;
32664 bool result;
32665 PyObject * obj0 = 0 ;
32666 char *kwnames[] = {
32667 (char *) "self", NULL
32668 };
32669
32670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
32671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32672 if (SWIG_arg_fail(1)) SWIG_fail;
32673 {
32674 PyThreadState* __tstate = wxPyBeginAllowThreads();
32675 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
32676
32677 wxPyEndAllowThreads(__tstate);
32678 if (PyErr_Occurred()) SWIG_fail;
32679 }
32680 {
32681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32682 }
32683 return resultobj;
32684 fail:
32685 return NULL;
32686 }
32687
32688
32689 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
32690 PyObject *resultobj = NULL;
32691 wxWindow *arg1 = (wxWindow *) 0 ;
32692 bool result;
32693 PyObject * obj0 = 0 ;
32694 char *kwnames[] = {
32695 (char *) "self", NULL
32696 };
32697
32698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
32699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32700 if (SWIG_arg_fail(1)) SWIG_fail;
32701 {
32702 PyThreadState* __tstate = wxPyBeginAllowThreads();
32703 result = (bool)(arg1)->Layout();
32704
32705 wxPyEndAllowThreads(__tstate);
32706 if (PyErr_Occurred()) SWIG_fail;
32707 }
32708 {
32709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32710 }
32711 return resultobj;
32712 fail:
32713 return NULL;
32714 }
32715
32716
32717 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32718 PyObject *resultobj = NULL;
32719 wxWindow *arg1 = (wxWindow *) 0 ;
32720 wxSizer *arg2 = (wxSizer *) 0 ;
32721 bool arg3 = (bool) true ;
32722 PyObject * obj0 = 0 ;
32723 PyObject * obj1 = 0 ;
32724 PyObject * obj2 = 0 ;
32725 char *kwnames[] = {
32726 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32727 };
32728
32729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
32730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32731 if (SWIG_arg_fail(1)) SWIG_fail;
32732 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32733 if (SWIG_arg_fail(2)) SWIG_fail;
32734 if (obj2) {
32735 {
32736 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
32737 if (SWIG_arg_fail(3)) SWIG_fail;
32738 }
32739 }
32740 {
32741 PyThreadState* __tstate = wxPyBeginAllowThreads();
32742 (arg1)->SetSizer(arg2,arg3);
32743
32744 wxPyEndAllowThreads(__tstate);
32745 if (PyErr_Occurred()) SWIG_fail;
32746 }
32747 Py_INCREF(Py_None); resultobj = Py_None;
32748 return resultobj;
32749 fail:
32750 return NULL;
32751 }
32752
32753
32754 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
32755 PyObject *resultobj = NULL;
32756 wxWindow *arg1 = (wxWindow *) 0 ;
32757 wxSizer *arg2 = (wxSizer *) 0 ;
32758 bool arg3 = (bool) true ;
32759 PyObject * obj0 = 0 ;
32760 PyObject * obj1 = 0 ;
32761 PyObject * obj2 = 0 ;
32762 char *kwnames[] = {
32763 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32764 };
32765
32766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
32767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32768 if (SWIG_arg_fail(1)) SWIG_fail;
32769 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32770 if (SWIG_arg_fail(2)) SWIG_fail;
32771 if (obj2) {
32772 {
32773 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
32774 if (SWIG_arg_fail(3)) SWIG_fail;
32775 }
32776 }
32777 {
32778 PyThreadState* __tstate = wxPyBeginAllowThreads();
32779 (arg1)->SetSizerAndFit(arg2,arg3);
32780
32781 wxPyEndAllowThreads(__tstate);
32782 if (PyErr_Occurred()) SWIG_fail;
32783 }
32784 Py_INCREF(Py_None); resultobj = Py_None;
32785 return resultobj;
32786 fail:
32787 return NULL;
32788 }
32789
32790
32791 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32792 PyObject *resultobj = NULL;
32793 wxWindow *arg1 = (wxWindow *) 0 ;
32794 wxSizer *result;
32795 PyObject * obj0 = 0 ;
32796 char *kwnames[] = {
32797 (char *) "self", NULL
32798 };
32799
32800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32802 if (SWIG_arg_fail(1)) SWIG_fail;
32803 {
32804 PyThreadState* __tstate = wxPyBeginAllowThreads();
32805 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32806
32807 wxPyEndAllowThreads(__tstate);
32808 if (PyErr_Occurred()) SWIG_fail;
32809 }
32810 {
32811 resultobj = wxPyMake_wxObject(result, (bool)0);
32812 }
32813 return resultobj;
32814 fail:
32815 return NULL;
32816 }
32817
32818
32819 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32820 PyObject *resultobj = NULL;
32821 wxWindow *arg1 = (wxWindow *) 0 ;
32822 wxSizer *arg2 = (wxSizer *) 0 ;
32823 PyObject * obj0 = 0 ;
32824 PyObject * obj1 = 0 ;
32825 char *kwnames[] = {
32826 (char *) "self",(char *) "sizer", NULL
32827 };
32828
32829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32831 if (SWIG_arg_fail(1)) SWIG_fail;
32832 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32833 if (SWIG_arg_fail(2)) SWIG_fail;
32834 {
32835 PyThreadState* __tstate = wxPyBeginAllowThreads();
32836 (arg1)->SetContainingSizer(arg2);
32837
32838 wxPyEndAllowThreads(__tstate);
32839 if (PyErr_Occurred()) SWIG_fail;
32840 }
32841 Py_INCREF(Py_None); resultobj = Py_None;
32842 return resultobj;
32843 fail:
32844 return NULL;
32845 }
32846
32847
32848 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32849 PyObject *resultobj = NULL;
32850 wxWindow *arg1 = (wxWindow *) 0 ;
32851 wxSizer *result;
32852 PyObject * obj0 = 0 ;
32853 char *kwnames[] = {
32854 (char *) "self", NULL
32855 };
32856
32857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32859 if (SWIG_arg_fail(1)) SWIG_fail;
32860 {
32861 PyThreadState* __tstate = wxPyBeginAllowThreads();
32862 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32863
32864 wxPyEndAllowThreads(__tstate);
32865 if (PyErr_Occurred()) SWIG_fail;
32866 }
32867 {
32868 resultobj = wxPyMake_wxObject(result, (bool)0);
32869 }
32870 return resultobj;
32871 fail:
32872 return NULL;
32873 }
32874
32875
32876 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32877 PyObject *resultobj = NULL;
32878 wxWindow *arg1 = (wxWindow *) 0 ;
32879 PyObject * obj0 = 0 ;
32880 char *kwnames[] = {
32881 (char *) "self", NULL
32882 };
32883
32884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32886 if (SWIG_arg_fail(1)) SWIG_fail;
32887 {
32888 PyThreadState* __tstate = wxPyBeginAllowThreads();
32889 (arg1)->InheritAttributes();
32890
32891 wxPyEndAllowThreads(__tstate);
32892 if (PyErr_Occurred()) SWIG_fail;
32893 }
32894 Py_INCREF(Py_None); resultobj = Py_None;
32895 return resultobj;
32896 fail:
32897 return NULL;
32898 }
32899
32900
32901 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32902 PyObject *resultobj = NULL;
32903 wxWindow *arg1 = (wxWindow *) 0 ;
32904 bool result;
32905 PyObject * obj0 = 0 ;
32906 char *kwnames[] = {
32907 (char *) "self", NULL
32908 };
32909
32910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32912 if (SWIG_arg_fail(1)) SWIG_fail;
32913 {
32914 PyThreadState* __tstate = wxPyBeginAllowThreads();
32915 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32916
32917 wxPyEndAllowThreads(__tstate);
32918 if (PyErr_Occurred()) SWIG_fail;
32919 }
32920 {
32921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32922 }
32923 return resultobj;
32924 fail:
32925 return NULL;
32926 }
32927
32928
32929 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32930 PyObject *obj;
32931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32932 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32933 Py_INCREF(obj);
32934 return Py_BuildValue((char *)"");
32935 }
32936 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32937 PyObject *resultobj = NULL;
32938 long arg1 ;
32939 wxWindow *arg2 = (wxWindow *) NULL ;
32940 wxWindow *result;
32941 PyObject * obj0 = 0 ;
32942 PyObject * obj1 = 0 ;
32943 char *kwnames[] = {
32944 (char *) "id",(char *) "parent", NULL
32945 };
32946
32947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32948 {
32949 arg1 = static_cast<long >(SWIG_As_long(obj0));
32950 if (SWIG_arg_fail(1)) SWIG_fail;
32951 }
32952 if (obj1) {
32953 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32954 if (SWIG_arg_fail(2)) SWIG_fail;
32955 }
32956 {
32957 if (!wxPyCheckForApp()) SWIG_fail;
32958 PyThreadState* __tstate = wxPyBeginAllowThreads();
32959 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32960
32961 wxPyEndAllowThreads(__tstate);
32962 if (PyErr_Occurred()) SWIG_fail;
32963 }
32964 {
32965 resultobj = wxPyMake_wxObject(result, 0);
32966 }
32967 return resultobj;
32968 fail:
32969 return NULL;
32970 }
32971
32972
32973 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32974 PyObject *resultobj = NULL;
32975 wxString *arg1 = 0 ;
32976 wxWindow *arg2 = (wxWindow *) NULL ;
32977 wxWindow *result;
32978 bool temp1 = false ;
32979 PyObject * obj0 = 0 ;
32980 PyObject * obj1 = 0 ;
32981 char *kwnames[] = {
32982 (char *) "name",(char *) "parent", NULL
32983 };
32984
32985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32986 {
32987 arg1 = wxString_in_helper(obj0);
32988 if (arg1 == NULL) SWIG_fail;
32989 temp1 = true;
32990 }
32991 if (obj1) {
32992 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32993 if (SWIG_arg_fail(2)) SWIG_fail;
32994 }
32995 {
32996 if (!wxPyCheckForApp()) SWIG_fail;
32997 PyThreadState* __tstate = wxPyBeginAllowThreads();
32998 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32999
33000 wxPyEndAllowThreads(__tstate);
33001 if (PyErr_Occurred()) SWIG_fail;
33002 }
33003 {
33004 resultobj = wxPyMake_wxObject(result, 0);
33005 }
33006 {
33007 if (temp1)
33008 delete arg1;
33009 }
33010 return resultobj;
33011 fail:
33012 {
33013 if (temp1)
33014 delete arg1;
33015 }
33016 return NULL;
33017 }
33018
33019
33020 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33021 PyObject *resultobj = NULL;
33022 wxString *arg1 = 0 ;
33023 wxWindow *arg2 = (wxWindow *) NULL ;
33024 wxWindow *result;
33025 bool temp1 = false ;
33026 PyObject * obj0 = 0 ;
33027 PyObject * obj1 = 0 ;
33028 char *kwnames[] = {
33029 (char *) "label",(char *) "parent", NULL
33030 };
33031
33032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
33033 {
33034 arg1 = wxString_in_helper(obj0);
33035 if (arg1 == NULL) SWIG_fail;
33036 temp1 = true;
33037 }
33038 if (obj1) {
33039 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33040 if (SWIG_arg_fail(2)) SWIG_fail;
33041 }
33042 {
33043 if (!wxPyCheckForApp()) SWIG_fail;
33044 PyThreadState* __tstate = wxPyBeginAllowThreads();
33045 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
33046
33047 wxPyEndAllowThreads(__tstate);
33048 if (PyErr_Occurred()) SWIG_fail;
33049 }
33050 {
33051 resultobj = wxPyMake_wxObject(result, 0);
33052 }
33053 {
33054 if (temp1)
33055 delete arg1;
33056 }
33057 return resultobj;
33058 fail:
33059 {
33060 if (temp1)
33061 delete arg1;
33062 }
33063 return NULL;
33064 }
33065
33066
33067 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
33068 PyObject *resultobj = NULL;
33069 wxWindow *arg1 = (wxWindow *) 0 ;
33070 unsigned long arg2 ;
33071 wxWindow *result;
33072 PyObject * obj0 = 0 ;
33073 PyObject * obj1 = 0 ;
33074 char *kwnames[] = {
33075 (char *) "parent",(char *) "_hWnd", NULL
33076 };
33077
33078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
33079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33080 if (SWIG_arg_fail(1)) SWIG_fail;
33081 {
33082 arg2 = static_cast<unsigned long >(SWIG_As_unsigned_SS_long(obj1));
33083 if (SWIG_arg_fail(2)) SWIG_fail;
33084 }
33085 {
33086 PyThreadState* __tstate = wxPyBeginAllowThreads();
33087 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
33088
33089 wxPyEndAllowThreads(__tstate);
33090 if (PyErr_Occurred()) SWIG_fail;
33091 }
33092 {
33093 resultobj = wxPyMake_wxObject(result, 0);
33094 }
33095 return resultobj;
33096 fail:
33097 return NULL;
33098 }
33099
33100
33101 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
33102 PyObject *resultobj = NULL;
33103 PyObject *result;
33104 char *kwnames[] = {
33105 NULL
33106 };
33107
33108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
33109 {
33110 PyThreadState* __tstate = wxPyBeginAllowThreads();
33111 result = (PyObject *)GetTopLevelWindows();
33112
33113 wxPyEndAllowThreads(__tstate);
33114 if (PyErr_Occurred()) SWIG_fail;
33115 }
33116 resultobj = result;
33117 return resultobj;
33118 fail:
33119 return NULL;
33120 }
33121
33122
33123 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
33124 PyObject *resultobj = NULL;
33125 wxValidator *result;
33126 char *kwnames[] = {
33127 NULL
33128 };
33129
33130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
33131 {
33132 PyThreadState* __tstate = wxPyBeginAllowThreads();
33133 result = (wxValidator *)new wxValidator();
33134
33135 wxPyEndAllowThreads(__tstate);
33136 if (PyErr_Occurred()) SWIG_fail;
33137 }
33138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
33139 return resultobj;
33140 fail:
33141 return NULL;
33142 }
33143
33144
33145 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
33146 PyObject *resultobj = NULL;
33147 wxValidator *arg1 = (wxValidator *) 0 ;
33148 wxValidator *result;
33149 PyObject * obj0 = 0 ;
33150 char *kwnames[] = {
33151 (char *) "self", NULL
33152 };
33153
33154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
33155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33156 if (SWIG_arg_fail(1)) SWIG_fail;
33157 {
33158 PyThreadState* __tstate = wxPyBeginAllowThreads();
33159 result = (wxValidator *)(arg1)->Clone();
33160
33161 wxPyEndAllowThreads(__tstate);
33162 if (PyErr_Occurred()) SWIG_fail;
33163 }
33164 {
33165 resultobj = wxPyMake_wxObject(result, 0);
33166 }
33167 return resultobj;
33168 fail:
33169 return NULL;
33170 }
33171
33172
33173 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
33174 PyObject *resultobj = NULL;
33175 wxValidator *arg1 = (wxValidator *) 0 ;
33176 wxWindow *arg2 = (wxWindow *) 0 ;
33177 bool result;
33178 PyObject * obj0 = 0 ;
33179 PyObject * obj1 = 0 ;
33180 char *kwnames[] = {
33181 (char *) "self",(char *) "parent", NULL
33182 };
33183
33184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
33185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33186 if (SWIG_arg_fail(1)) SWIG_fail;
33187 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33188 if (SWIG_arg_fail(2)) SWIG_fail;
33189 {
33190 PyThreadState* __tstate = wxPyBeginAllowThreads();
33191 result = (bool)(arg1)->Validate(arg2);
33192
33193 wxPyEndAllowThreads(__tstate);
33194 if (PyErr_Occurred()) SWIG_fail;
33195 }
33196 {
33197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33198 }
33199 return resultobj;
33200 fail:
33201 return NULL;
33202 }
33203
33204
33205 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33206 PyObject *resultobj = NULL;
33207 wxValidator *arg1 = (wxValidator *) 0 ;
33208 bool result;
33209 PyObject * obj0 = 0 ;
33210 char *kwnames[] = {
33211 (char *) "self", NULL
33212 };
33213
33214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
33215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33216 if (SWIG_arg_fail(1)) SWIG_fail;
33217 {
33218 PyThreadState* __tstate = wxPyBeginAllowThreads();
33219 result = (bool)(arg1)->TransferToWindow();
33220
33221 wxPyEndAllowThreads(__tstate);
33222 if (PyErr_Occurred()) SWIG_fail;
33223 }
33224 {
33225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33226 }
33227 return resultobj;
33228 fail:
33229 return NULL;
33230 }
33231
33232
33233 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33234 PyObject *resultobj = NULL;
33235 wxValidator *arg1 = (wxValidator *) 0 ;
33236 bool result;
33237 PyObject * obj0 = 0 ;
33238 char *kwnames[] = {
33239 (char *) "self", NULL
33240 };
33241
33242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
33243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33244 if (SWIG_arg_fail(1)) SWIG_fail;
33245 {
33246 PyThreadState* __tstate = wxPyBeginAllowThreads();
33247 result = (bool)(arg1)->TransferFromWindow();
33248
33249 wxPyEndAllowThreads(__tstate);
33250 if (PyErr_Occurred()) SWIG_fail;
33251 }
33252 {
33253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33254 }
33255 return resultobj;
33256 fail:
33257 return NULL;
33258 }
33259
33260
33261 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33262 PyObject *resultobj = NULL;
33263 wxValidator *arg1 = (wxValidator *) 0 ;
33264 wxWindow *result;
33265 PyObject * obj0 = 0 ;
33266 char *kwnames[] = {
33267 (char *) "self", NULL
33268 };
33269
33270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
33271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33272 if (SWIG_arg_fail(1)) SWIG_fail;
33273 {
33274 PyThreadState* __tstate = wxPyBeginAllowThreads();
33275 result = (wxWindow *)(arg1)->GetWindow();
33276
33277 wxPyEndAllowThreads(__tstate);
33278 if (PyErr_Occurred()) SWIG_fail;
33279 }
33280 {
33281 resultobj = wxPyMake_wxObject(result, 0);
33282 }
33283 return resultobj;
33284 fail:
33285 return NULL;
33286 }
33287
33288
33289 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33290 PyObject *resultobj = NULL;
33291 wxValidator *arg1 = (wxValidator *) 0 ;
33292 wxWindow *arg2 = (wxWindow *) 0 ;
33293 PyObject * obj0 = 0 ;
33294 PyObject * obj1 = 0 ;
33295 char *kwnames[] = {
33296 (char *) "self",(char *) "window", NULL
33297 };
33298
33299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
33300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
33301 if (SWIG_arg_fail(1)) SWIG_fail;
33302 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33303 if (SWIG_arg_fail(2)) SWIG_fail;
33304 {
33305 PyThreadState* __tstate = wxPyBeginAllowThreads();
33306 (arg1)->SetWindow(arg2);
33307
33308 wxPyEndAllowThreads(__tstate);
33309 if (PyErr_Occurred()) SWIG_fail;
33310 }
33311 Py_INCREF(Py_None); resultobj = Py_None;
33312 return resultobj;
33313 fail:
33314 return NULL;
33315 }
33316
33317
33318 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
33319 PyObject *resultobj = NULL;
33320 bool result;
33321 char *kwnames[] = {
33322 NULL
33323 };
33324
33325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
33326 {
33327 PyThreadState* __tstate = wxPyBeginAllowThreads();
33328 result = (bool)wxValidator::IsSilent();
33329
33330 wxPyEndAllowThreads(__tstate);
33331 if (PyErr_Occurred()) SWIG_fail;
33332 }
33333 {
33334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33335 }
33336 return resultobj;
33337 fail:
33338 return NULL;
33339 }
33340
33341
33342 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
33343 PyObject *resultobj = NULL;
33344 int arg1 = (int) true ;
33345 PyObject * obj0 = 0 ;
33346 char *kwnames[] = {
33347 (char *) "doIt", NULL
33348 };
33349
33350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
33351 if (obj0) {
33352 {
33353 arg1 = static_cast<int >(SWIG_As_int(obj0));
33354 if (SWIG_arg_fail(1)) SWIG_fail;
33355 }
33356 }
33357 {
33358 PyThreadState* __tstate = wxPyBeginAllowThreads();
33359 wxValidator::SetBellOnError(arg1);
33360
33361 wxPyEndAllowThreads(__tstate);
33362 if (PyErr_Occurred()) SWIG_fail;
33363 }
33364 Py_INCREF(Py_None); resultobj = Py_None;
33365 return resultobj;
33366 fail:
33367 return NULL;
33368 }
33369
33370
33371 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
33372 PyObject *obj;
33373 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33374 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
33375 Py_INCREF(obj);
33376 return Py_BuildValue((char *)"");
33377 }
33378 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
33379 PyObject *resultobj = NULL;
33380 wxPyValidator *result;
33381 char *kwnames[] = {
33382 NULL
33383 };
33384
33385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
33386 {
33387 PyThreadState* __tstate = wxPyBeginAllowThreads();
33388 result = (wxPyValidator *)new wxPyValidator();
33389
33390 wxPyEndAllowThreads(__tstate);
33391 if (PyErr_Occurred()) SWIG_fail;
33392 }
33393 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
33394 return resultobj;
33395 fail:
33396 return NULL;
33397 }
33398
33399
33400 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
33401 PyObject *resultobj = NULL;
33402 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
33403 PyObject *arg2 = (PyObject *) 0 ;
33404 PyObject *arg3 = (PyObject *) 0 ;
33405 int arg4 = (int) true ;
33406 PyObject * obj0 = 0 ;
33407 PyObject * obj1 = 0 ;
33408 PyObject * obj2 = 0 ;
33409 PyObject * obj3 = 0 ;
33410 char *kwnames[] = {
33411 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33412 };
33413
33414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
33416 if (SWIG_arg_fail(1)) SWIG_fail;
33417 arg2 = obj1;
33418 arg3 = obj2;
33419 if (obj3) {
33420 {
33421 arg4 = static_cast<int >(SWIG_As_int(obj3));
33422 if (SWIG_arg_fail(4)) SWIG_fail;
33423 }
33424 }
33425 {
33426 PyThreadState* __tstate = wxPyBeginAllowThreads();
33427 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33428
33429 wxPyEndAllowThreads(__tstate);
33430 if (PyErr_Occurred()) SWIG_fail;
33431 }
33432 Py_INCREF(Py_None); resultobj = Py_None;
33433 return resultobj;
33434 fail:
33435 return NULL;
33436 }
33437
33438
33439 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
33440 PyObject *obj;
33441 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33442 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
33443 Py_INCREF(obj);
33444 return Py_BuildValue((char *)"");
33445 }
33446 static int _wrap_DefaultValidator_set(PyObject *) {
33447 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
33448 return 1;
33449 }
33450
33451
33452 static PyObject *_wrap_DefaultValidator_get(void) {
33453 PyObject *pyobj = NULL;
33454
33455 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
33456 return pyobj;
33457 }
33458
33459
33460 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
33461 PyObject *resultobj = NULL;
33462 wxString const &arg1_defvalue = wxPyEmptyString ;
33463 wxString *arg1 = (wxString *) &arg1_defvalue ;
33464 long arg2 = (long) 0 ;
33465 wxMenu *result;
33466 bool temp1 = false ;
33467 PyObject * obj0 = 0 ;
33468 PyObject * obj1 = 0 ;
33469 char *kwnames[] = {
33470 (char *) "title",(char *) "style", NULL
33471 };
33472
33473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
33474 if (obj0) {
33475 {
33476 arg1 = wxString_in_helper(obj0);
33477 if (arg1 == NULL) SWIG_fail;
33478 temp1 = true;
33479 }
33480 }
33481 if (obj1) {
33482 {
33483 arg2 = static_cast<long >(SWIG_As_long(obj1));
33484 if (SWIG_arg_fail(2)) SWIG_fail;
33485 }
33486 }
33487 {
33488 if (!wxPyCheckForApp()) SWIG_fail;
33489 PyThreadState* __tstate = wxPyBeginAllowThreads();
33490 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
33491
33492 wxPyEndAllowThreads(__tstate);
33493 if (PyErr_Occurred()) SWIG_fail;
33494 }
33495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
33496 {
33497 if (temp1)
33498 delete arg1;
33499 }
33500 return resultobj;
33501 fail:
33502 {
33503 if (temp1)
33504 delete arg1;
33505 }
33506 return NULL;
33507 }
33508
33509
33510 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
33511 PyObject *resultobj = NULL;
33512 wxMenu *arg1 = (wxMenu *) 0 ;
33513 int arg2 ;
33514 wxString *arg3 = 0 ;
33515 wxString const &arg4_defvalue = wxPyEmptyString ;
33516 wxString *arg4 = (wxString *) &arg4_defvalue ;
33517 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33518 wxMenuItem *result;
33519 bool temp3 = false ;
33520 bool temp4 = false ;
33521 PyObject * obj0 = 0 ;
33522 PyObject * obj1 = 0 ;
33523 PyObject * obj2 = 0 ;
33524 PyObject * obj3 = 0 ;
33525 PyObject * obj4 = 0 ;
33526 char *kwnames[] = {
33527 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33528 };
33529
33530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33532 if (SWIG_arg_fail(1)) SWIG_fail;
33533 {
33534 arg2 = static_cast<int >(SWIG_As_int(obj1));
33535 if (SWIG_arg_fail(2)) SWIG_fail;
33536 }
33537 {
33538 arg3 = wxString_in_helper(obj2);
33539 if (arg3 == NULL) SWIG_fail;
33540 temp3 = true;
33541 }
33542 if (obj3) {
33543 {
33544 arg4 = wxString_in_helper(obj3);
33545 if (arg4 == NULL) SWIG_fail;
33546 temp4 = true;
33547 }
33548 }
33549 if (obj4) {
33550 {
33551 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
33552 if (SWIG_arg_fail(5)) SWIG_fail;
33553 }
33554 }
33555 {
33556 PyThreadState* __tstate = wxPyBeginAllowThreads();
33557 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
33558
33559 wxPyEndAllowThreads(__tstate);
33560 if (PyErr_Occurred()) SWIG_fail;
33561 }
33562 {
33563 resultobj = wxPyMake_wxObject(result, (bool)0);
33564 }
33565 {
33566 if (temp3)
33567 delete arg3;
33568 }
33569 {
33570 if (temp4)
33571 delete arg4;
33572 }
33573 return resultobj;
33574 fail:
33575 {
33576 if (temp3)
33577 delete arg3;
33578 }
33579 {
33580 if (temp4)
33581 delete arg4;
33582 }
33583 return NULL;
33584 }
33585
33586
33587 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33588 PyObject *resultobj = NULL;
33589 wxMenu *arg1 = (wxMenu *) 0 ;
33590 wxMenuItem *result;
33591 PyObject * obj0 = 0 ;
33592 char *kwnames[] = {
33593 (char *) "self", NULL
33594 };
33595
33596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
33597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33598 if (SWIG_arg_fail(1)) SWIG_fail;
33599 {
33600 PyThreadState* __tstate = wxPyBeginAllowThreads();
33601 result = (wxMenuItem *)(arg1)->AppendSeparator();
33602
33603 wxPyEndAllowThreads(__tstate);
33604 if (PyErr_Occurred()) SWIG_fail;
33605 }
33606 {
33607 resultobj = wxPyMake_wxObject(result, (bool)0);
33608 }
33609 return resultobj;
33610 fail:
33611 return NULL;
33612 }
33613
33614
33615 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33616 PyObject *resultobj = NULL;
33617 wxMenu *arg1 = (wxMenu *) 0 ;
33618 int arg2 ;
33619 wxString *arg3 = 0 ;
33620 wxString const &arg4_defvalue = wxPyEmptyString ;
33621 wxString *arg4 = (wxString *) &arg4_defvalue ;
33622 wxMenuItem *result;
33623 bool temp3 = false ;
33624 bool temp4 = false ;
33625 PyObject * obj0 = 0 ;
33626 PyObject * obj1 = 0 ;
33627 PyObject * obj2 = 0 ;
33628 PyObject * obj3 = 0 ;
33629 char *kwnames[] = {
33630 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33631 };
33632
33633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33635 if (SWIG_arg_fail(1)) SWIG_fail;
33636 {
33637 arg2 = static_cast<int >(SWIG_As_int(obj1));
33638 if (SWIG_arg_fail(2)) SWIG_fail;
33639 }
33640 {
33641 arg3 = wxString_in_helper(obj2);
33642 if (arg3 == NULL) SWIG_fail;
33643 temp3 = true;
33644 }
33645 if (obj3) {
33646 {
33647 arg4 = wxString_in_helper(obj3);
33648 if (arg4 == NULL) SWIG_fail;
33649 temp4 = true;
33650 }
33651 }
33652 {
33653 PyThreadState* __tstate = wxPyBeginAllowThreads();
33654 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33655
33656 wxPyEndAllowThreads(__tstate);
33657 if (PyErr_Occurred()) SWIG_fail;
33658 }
33659 {
33660 resultobj = wxPyMake_wxObject(result, (bool)0);
33661 }
33662 {
33663 if (temp3)
33664 delete arg3;
33665 }
33666 {
33667 if (temp4)
33668 delete arg4;
33669 }
33670 return resultobj;
33671 fail:
33672 {
33673 if (temp3)
33674 delete arg3;
33675 }
33676 {
33677 if (temp4)
33678 delete arg4;
33679 }
33680 return NULL;
33681 }
33682
33683
33684 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33685 PyObject *resultobj = NULL;
33686 wxMenu *arg1 = (wxMenu *) 0 ;
33687 int arg2 ;
33688 wxString *arg3 = 0 ;
33689 wxString const &arg4_defvalue = wxPyEmptyString ;
33690 wxString *arg4 = (wxString *) &arg4_defvalue ;
33691 wxMenuItem *result;
33692 bool temp3 = false ;
33693 bool temp4 = false ;
33694 PyObject * obj0 = 0 ;
33695 PyObject * obj1 = 0 ;
33696 PyObject * obj2 = 0 ;
33697 PyObject * obj3 = 0 ;
33698 char *kwnames[] = {
33699 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33700 };
33701
33702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33704 if (SWIG_arg_fail(1)) SWIG_fail;
33705 {
33706 arg2 = static_cast<int >(SWIG_As_int(obj1));
33707 if (SWIG_arg_fail(2)) SWIG_fail;
33708 }
33709 {
33710 arg3 = wxString_in_helper(obj2);
33711 if (arg3 == NULL) SWIG_fail;
33712 temp3 = true;
33713 }
33714 if (obj3) {
33715 {
33716 arg4 = wxString_in_helper(obj3);
33717 if (arg4 == NULL) SWIG_fail;
33718 temp4 = true;
33719 }
33720 }
33721 {
33722 PyThreadState* __tstate = wxPyBeginAllowThreads();
33723 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33724
33725 wxPyEndAllowThreads(__tstate);
33726 if (PyErr_Occurred()) SWIG_fail;
33727 }
33728 {
33729 resultobj = wxPyMake_wxObject(result, (bool)0);
33730 }
33731 {
33732 if (temp3)
33733 delete arg3;
33734 }
33735 {
33736 if (temp4)
33737 delete arg4;
33738 }
33739 return resultobj;
33740 fail:
33741 {
33742 if (temp3)
33743 delete arg3;
33744 }
33745 {
33746 if (temp4)
33747 delete arg4;
33748 }
33749 return NULL;
33750 }
33751
33752
33753 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33754 PyObject *resultobj = NULL;
33755 wxMenu *arg1 = (wxMenu *) 0 ;
33756 int arg2 ;
33757 wxString *arg3 = 0 ;
33758 wxMenu *arg4 = (wxMenu *) 0 ;
33759 wxString const &arg5_defvalue = wxPyEmptyString ;
33760 wxString *arg5 = (wxString *) &arg5_defvalue ;
33761 wxMenuItem *result;
33762 bool temp3 = false ;
33763 bool temp5 = false ;
33764 PyObject * obj0 = 0 ;
33765 PyObject * obj1 = 0 ;
33766 PyObject * obj2 = 0 ;
33767 PyObject * obj3 = 0 ;
33768 PyObject * obj4 = 0 ;
33769 char *kwnames[] = {
33770 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33771 };
33772
33773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33775 if (SWIG_arg_fail(1)) SWIG_fail;
33776 {
33777 arg2 = static_cast<int >(SWIG_As_int(obj1));
33778 if (SWIG_arg_fail(2)) SWIG_fail;
33779 }
33780 {
33781 arg3 = wxString_in_helper(obj2);
33782 if (arg3 == NULL) SWIG_fail;
33783 temp3 = true;
33784 }
33785 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33786 if (SWIG_arg_fail(4)) SWIG_fail;
33787 if (obj4) {
33788 {
33789 arg5 = wxString_in_helper(obj4);
33790 if (arg5 == NULL) SWIG_fail;
33791 temp5 = true;
33792 }
33793 }
33794 {
33795 PyThreadState* __tstate = wxPyBeginAllowThreads();
33796 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33797
33798 wxPyEndAllowThreads(__tstate);
33799 if (PyErr_Occurred()) SWIG_fail;
33800 }
33801 {
33802 resultobj = wxPyMake_wxObject(result, (bool)0);
33803 }
33804 {
33805 if (temp3)
33806 delete arg3;
33807 }
33808 {
33809 if (temp5)
33810 delete arg5;
33811 }
33812 return resultobj;
33813 fail:
33814 {
33815 if (temp3)
33816 delete arg3;
33817 }
33818 {
33819 if (temp5)
33820 delete arg5;
33821 }
33822 return NULL;
33823 }
33824
33825
33826 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33827 PyObject *resultobj = NULL;
33828 wxMenu *arg1 = (wxMenu *) 0 ;
33829 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33830 wxMenuItem *result;
33831 PyObject * obj0 = 0 ;
33832 PyObject * obj1 = 0 ;
33833 char *kwnames[] = {
33834 (char *) "self",(char *) "item", NULL
33835 };
33836
33837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33839 if (SWIG_arg_fail(1)) SWIG_fail;
33840 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33841 if (SWIG_arg_fail(2)) SWIG_fail;
33842 {
33843 PyThreadState* __tstate = wxPyBeginAllowThreads();
33844 result = (wxMenuItem *)(arg1)->Append(arg2);
33845
33846 wxPyEndAllowThreads(__tstate);
33847 if (PyErr_Occurred()) SWIG_fail;
33848 }
33849 {
33850 resultobj = wxPyMake_wxObject(result, (bool)0);
33851 }
33852 return resultobj;
33853 fail:
33854 return NULL;
33855 }
33856
33857
33858 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33859 PyObject *resultobj = NULL;
33860 wxMenu *arg1 = (wxMenu *) 0 ;
33861 PyObject * obj0 = 0 ;
33862 char *kwnames[] = {
33863 (char *) "self", NULL
33864 };
33865
33866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33868 if (SWIG_arg_fail(1)) SWIG_fail;
33869 {
33870 PyThreadState* __tstate = wxPyBeginAllowThreads();
33871 (arg1)->Break();
33872
33873 wxPyEndAllowThreads(__tstate);
33874 if (PyErr_Occurred()) SWIG_fail;
33875 }
33876 Py_INCREF(Py_None); resultobj = Py_None;
33877 return resultobj;
33878 fail:
33879 return NULL;
33880 }
33881
33882
33883 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33884 PyObject *resultobj = NULL;
33885 wxMenu *arg1 = (wxMenu *) 0 ;
33886 size_t arg2 ;
33887 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33888 wxMenuItem *result;
33889 PyObject * obj0 = 0 ;
33890 PyObject * obj1 = 0 ;
33891 PyObject * obj2 = 0 ;
33892 char *kwnames[] = {
33893 (char *) "self",(char *) "pos",(char *) "item", NULL
33894 };
33895
33896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33898 if (SWIG_arg_fail(1)) SWIG_fail;
33899 {
33900 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
33901 if (SWIG_arg_fail(2)) SWIG_fail;
33902 }
33903 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33904 if (SWIG_arg_fail(3)) SWIG_fail;
33905 {
33906 PyThreadState* __tstate = wxPyBeginAllowThreads();
33907 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33908
33909 wxPyEndAllowThreads(__tstate);
33910 if (PyErr_Occurred()) SWIG_fail;
33911 }
33912 {
33913 resultobj = wxPyMake_wxObject(result, (bool)0);
33914 }
33915 return resultobj;
33916 fail:
33917 return NULL;
33918 }
33919
33920
33921 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33922 PyObject *resultobj = NULL;
33923 wxMenu *arg1 = (wxMenu *) 0 ;
33924 size_t arg2 ;
33925 int arg3 ;
33926 wxString *arg4 = 0 ;
33927 wxString const &arg5_defvalue = wxPyEmptyString ;
33928 wxString *arg5 = (wxString *) &arg5_defvalue ;
33929 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33930 wxMenuItem *result;
33931 bool temp4 = false ;
33932 bool temp5 = false ;
33933 PyObject * obj0 = 0 ;
33934 PyObject * obj1 = 0 ;
33935 PyObject * obj2 = 0 ;
33936 PyObject * obj3 = 0 ;
33937 PyObject * obj4 = 0 ;
33938 PyObject * obj5 = 0 ;
33939 char *kwnames[] = {
33940 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33941 };
33942
33943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33945 if (SWIG_arg_fail(1)) SWIG_fail;
33946 {
33947 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
33948 if (SWIG_arg_fail(2)) SWIG_fail;
33949 }
33950 {
33951 arg3 = static_cast<int >(SWIG_As_int(obj2));
33952 if (SWIG_arg_fail(3)) SWIG_fail;
33953 }
33954 {
33955 arg4 = wxString_in_helper(obj3);
33956 if (arg4 == NULL) SWIG_fail;
33957 temp4 = true;
33958 }
33959 if (obj4) {
33960 {
33961 arg5 = wxString_in_helper(obj4);
33962 if (arg5 == NULL) SWIG_fail;
33963 temp5 = true;
33964 }
33965 }
33966 if (obj5) {
33967 {
33968 arg6 = static_cast<wxItemKind >(SWIG_As_int(obj5));
33969 if (SWIG_arg_fail(6)) SWIG_fail;
33970 }
33971 }
33972 {
33973 PyThreadState* __tstate = wxPyBeginAllowThreads();
33974 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
33975
33976 wxPyEndAllowThreads(__tstate);
33977 if (PyErr_Occurred()) SWIG_fail;
33978 }
33979 {
33980 resultobj = wxPyMake_wxObject(result, (bool)0);
33981 }
33982 {
33983 if (temp4)
33984 delete arg4;
33985 }
33986 {
33987 if (temp5)
33988 delete arg5;
33989 }
33990 return resultobj;
33991 fail:
33992 {
33993 if (temp4)
33994 delete arg4;
33995 }
33996 {
33997 if (temp5)
33998 delete arg5;
33999 }
34000 return NULL;
34001 }
34002
34003
34004 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
34005 PyObject *resultobj = NULL;
34006 wxMenu *arg1 = (wxMenu *) 0 ;
34007 size_t arg2 ;
34008 wxMenuItem *result;
34009 PyObject * obj0 = 0 ;
34010 PyObject * obj1 = 0 ;
34011 char *kwnames[] = {
34012 (char *) "self",(char *) "pos", NULL
34013 };
34014
34015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
34016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34017 if (SWIG_arg_fail(1)) SWIG_fail;
34018 {
34019 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34020 if (SWIG_arg_fail(2)) SWIG_fail;
34021 }
34022 {
34023 PyThreadState* __tstate = wxPyBeginAllowThreads();
34024 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
34025
34026 wxPyEndAllowThreads(__tstate);
34027 if (PyErr_Occurred()) SWIG_fail;
34028 }
34029 {
34030 resultobj = wxPyMake_wxObject(result, (bool)0);
34031 }
34032 return resultobj;
34033 fail:
34034 return NULL;
34035 }
34036
34037
34038 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34039 PyObject *resultobj = NULL;
34040 wxMenu *arg1 = (wxMenu *) 0 ;
34041 size_t arg2 ;
34042 int arg3 ;
34043 wxString *arg4 = 0 ;
34044 wxString const &arg5_defvalue = wxPyEmptyString ;
34045 wxString *arg5 = (wxString *) &arg5_defvalue ;
34046 wxMenuItem *result;
34047 bool temp4 = false ;
34048 bool temp5 = false ;
34049 PyObject * obj0 = 0 ;
34050 PyObject * obj1 = 0 ;
34051 PyObject * obj2 = 0 ;
34052 PyObject * obj3 = 0 ;
34053 PyObject * obj4 = 0 ;
34054 char *kwnames[] = {
34055 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
34056 };
34057
34058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34060 if (SWIG_arg_fail(1)) SWIG_fail;
34061 {
34062 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34063 if (SWIG_arg_fail(2)) SWIG_fail;
34064 }
34065 {
34066 arg3 = static_cast<int >(SWIG_As_int(obj2));
34067 if (SWIG_arg_fail(3)) SWIG_fail;
34068 }
34069 {
34070 arg4 = wxString_in_helper(obj3);
34071 if (arg4 == NULL) SWIG_fail;
34072 temp4 = true;
34073 }
34074 if (obj4) {
34075 {
34076 arg5 = wxString_in_helper(obj4);
34077 if (arg5 == NULL) SWIG_fail;
34078 temp5 = true;
34079 }
34080 }
34081 {
34082 PyThreadState* __tstate = wxPyBeginAllowThreads();
34083 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
34084
34085 wxPyEndAllowThreads(__tstate);
34086 if (PyErr_Occurred()) SWIG_fail;
34087 }
34088 {
34089 resultobj = wxPyMake_wxObject(result, (bool)0);
34090 }
34091 {
34092 if (temp4)
34093 delete arg4;
34094 }
34095 {
34096 if (temp5)
34097 delete arg5;
34098 }
34099 return resultobj;
34100 fail:
34101 {
34102 if (temp4)
34103 delete arg4;
34104 }
34105 {
34106 if (temp5)
34107 delete arg5;
34108 }
34109 return NULL;
34110 }
34111
34112
34113 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34114 PyObject *resultobj = NULL;
34115 wxMenu *arg1 = (wxMenu *) 0 ;
34116 size_t arg2 ;
34117 int arg3 ;
34118 wxString *arg4 = 0 ;
34119 wxString const &arg5_defvalue = wxPyEmptyString ;
34120 wxString *arg5 = (wxString *) &arg5_defvalue ;
34121 wxMenuItem *result;
34122 bool temp4 = false ;
34123 bool temp5 = false ;
34124 PyObject * obj0 = 0 ;
34125 PyObject * obj1 = 0 ;
34126 PyObject * obj2 = 0 ;
34127 PyObject * obj3 = 0 ;
34128 PyObject * obj4 = 0 ;
34129 char *kwnames[] = {
34130 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
34131 };
34132
34133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34135 if (SWIG_arg_fail(1)) SWIG_fail;
34136 {
34137 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34138 if (SWIG_arg_fail(2)) SWIG_fail;
34139 }
34140 {
34141 arg3 = static_cast<int >(SWIG_As_int(obj2));
34142 if (SWIG_arg_fail(3)) SWIG_fail;
34143 }
34144 {
34145 arg4 = wxString_in_helper(obj3);
34146 if (arg4 == NULL) SWIG_fail;
34147 temp4 = true;
34148 }
34149 if (obj4) {
34150 {
34151 arg5 = wxString_in_helper(obj4);
34152 if (arg5 == NULL) SWIG_fail;
34153 temp5 = true;
34154 }
34155 }
34156 {
34157 PyThreadState* __tstate = wxPyBeginAllowThreads();
34158 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
34159
34160 wxPyEndAllowThreads(__tstate);
34161 if (PyErr_Occurred()) SWIG_fail;
34162 }
34163 {
34164 resultobj = wxPyMake_wxObject(result, (bool)0);
34165 }
34166 {
34167 if (temp4)
34168 delete arg4;
34169 }
34170 {
34171 if (temp5)
34172 delete arg5;
34173 }
34174 return resultobj;
34175 fail:
34176 {
34177 if (temp4)
34178 delete arg4;
34179 }
34180 {
34181 if (temp5)
34182 delete arg5;
34183 }
34184 return NULL;
34185 }
34186
34187
34188 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34189 PyObject *resultobj = NULL;
34190 wxMenu *arg1 = (wxMenu *) 0 ;
34191 size_t arg2 ;
34192 int arg3 ;
34193 wxString *arg4 = 0 ;
34194 wxMenu *arg5 = (wxMenu *) 0 ;
34195 wxString const &arg6_defvalue = wxPyEmptyString ;
34196 wxString *arg6 = (wxString *) &arg6_defvalue ;
34197 wxMenuItem *result;
34198 bool temp4 = false ;
34199 bool temp6 = false ;
34200 PyObject * obj0 = 0 ;
34201 PyObject * obj1 = 0 ;
34202 PyObject * obj2 = 0 ;
34203 PyObject * obj3 = 0 ;
34204 PyObject * obj4 = 0 ;
34205 PyObject * obj5 = 0 ;
34206 char *kwnames[] = {
34207 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34208 };
34209
34210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
34211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34212 if (SWIG_arg_fail(1)) SWIG_fail;
34213 {
34214 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34215 if (SWIG_arg_fail(2)) SWIG_fail;
34216 }
34217 {
34218 arg3 = static_cast<int >(SWIG_As_int(obj2));
34219 if (SWIG_arg_fail(3)) SWIG_fail;
34220 }
34221 {
34222 arg4 = wxString_in_helper(obj3);
34223 if (arg4 == NULL) SWIG_fail;
34224 temp4 = true;
34225 }
34226 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34227 if (SWIG_arg_fail(5)) SWIG_fail;
34228 if (obj5) {
34229 {
34230 arg6 = wxString_in_helper(obj5);
34231 if (arg6 == NULL) SWIG_fail;
34232 temp6 = true;
34233 }
34234 }
34235 {
34236 PyThreadState* __tstate = wxPyBeginAllowThreads();
34237 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
34238
34239 wxPyEndAllowThreads(__tstate);
34240 if (PyErr_Occurred()) SWIG_fail;
34241 }
34242 {
34243 resultobj = wxPyMake_wxObject(result, (bool)0);
34244 }
34245 {
34246 if (temp4)
34247 delete arg4;
34248 }
34249 {
34250 if (temp6)
34251 delete arg6;
34252 }
34253 return resultobj;
34254 fail:
34255 {
34256 if (temp4)
34257 delete arg4;
34258 }
34259 {
34260 if (temp6)
34261 delete arg6;
34262 }
34263 return NULL;
34264 }
34265
34266
34267 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
34268 PyObject *resultobj = NULL;
34269 wxMenu *arg1 = (wxMenu *) 0 ;
34270 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34271 wxMenuItem *result;
34272 PyObject * obj0 = 0 ;
34273 PyObject * obj1 = 0 ;
34274 char *kwnames[] = {
34275 (char *) "self",(char *) "item", NULL
34276 };
34277
34278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
34279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34280 if (SWIG_arg_fail(1)) SWIG_fail;
34281 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34282 if (SWIG_arg_fail(2)) SWIG_fail;
34283 {
34284 PyThreadState* __tstate = wxPyBeginAllowThreads();
34285 result = (wxMenuItem *)(arg1)->Prepend(arg2);
34286
34287 wxPyEndAllowThreads(__tstate);
34288 if (PyErr_Occurred()) SWIG_fail;
34289 }
34290 {
34291 resultobj = wxPyMake_wxObject(result, (bool)0);
34292 }
34293 return resultobj;
34294 fail:
34295 return NULL;
34296 }
34297
34298
34299 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
34300 PyObject *resultobj = NULL;
34301 wxMenu *arg1 = (wxMenu *) 0 ;
34302 int arg2 ;
34303 wxString *arg3 = 0 ;
34304 wxString const &arg4_defvalue = wxPyEmptyString ;
34305 wxString *arg4 = (wxString *) &arg4_defvalue ;
34306 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
34307 wxMenuItem *result;
34308 bool temp3 = false ;
34309 bool temp4 = false ;
34310 PyObject * obj0 = 0 ;
34311 PyObject * obj1 = 0 ;
34312 PyObject * obj2 = 0 ;
34313 PyObject * obj3 = 0 ;
34314 PyObject * obj4 = 0 ;
34315 char *kwnames[] = {
34316 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
34317 };
34318
34319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34321 if (SWIG_arg_fail(1)) SWIG_fail;
34322 {
34323 arg2 = static_cast<int >(SWIG_As_int(obj1));
34324 if (SWIG_arg_fail(2)) SWIG_fail;
34325 }
34326 {
34327 arg3 = wxString_in_helper(obj2);
34328 if (arg3 == NULL) SWIG_fail;
34329 temp3 = true;
34330 }
34331 if (obj3) {
34332 {
34333 arg4 = wxString_in_helper(obj3);
34334 if (arg4 == NULL) SWIG_fail;
34335 temp4 = true;
34336 }
34337 }
34338 if (obj4) {
34339 {
34340 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
34341 if (SWIG_arg_fail(5)) SWIG_fail;
34342 }
34343 }
34344 {
34345 PyThreadState* __tstate = wxPyBeginAllowThreads();
34346 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
34347
34348 wxPyEndAllowThreads(__tstate);
34349 if (PyErr_Occurred()) SWIG_fail;
34350 }
34351 {
34352 resultobj = wxPyMake_wxObject(result, (bool)0);
34353 }
34354 {
34355 if (temp3)
34356 delete arg3;
34357 }
34358 {
34359 if (temp4)
34360 delete arg4;
34361 }
34362 return resultobj;
34363 fail:
34364 {
34365 if (temp3)
34366 delete arg3;
34367 }
34368 {
34369 if (temp4)
34370 delete arg4;
34371 }
34372 return NULL;
34373 }
34374
34375
34376 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
34377 PyObject *resultobj = NULL;
34378 wxMenu *arg1 = (wxMenu *) 0 ;
34379 wxMenuItem *result;
34380 PyObject * obj0 = 0 ;
34381 char *kwnames[] = {
34382 (char *) "self", NULL
34383 };
34384
34385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
34386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34387 if (SWIG_arg_fail(1)) SWIG_fail;
34388 {
34389 PyThreadState* __tstate = wxPyBeginAllowThreads();
34390 result = (wxMenuItem *)(arg1)->PrependSeparator();
34391
34392 wxPyEndAllowThreads(__tstate);
34393 if (PyErr_Occurred()) SWIG_fail;
34394 }
34395 {
34396 resultobj = wxPyMake_wxObject(result, (bool)0);
34397 }
34398 return resultobj;
34399 fail:
34400 return NULL;
34401 }
34402
34403
34404 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34405 PyObject *resultobj = NULL;
34406 wxMenu *arg1 = (wxMenu *) 0 ;
34407 int arg2 ;
34408 wxString *arg3 = 0 ;
34409 wxString const &arg4_defvalue = wxPyEmptyString ;
34410 wxString *arg4 = (wxString *) &arg4_defvalue ;
34411 wxMenuItem *result;
34412 bool temp3 = false ;
34413 bool temp4 = false ;
34414 PyObject * obj0 = 0 ;
34415 PyObject * obj1 = 0 ;
34416 PyObject * obj2 = 0 ;
34417 PyObject * obj3 = 0 ;
34418 char *kwnames[] = {
34419 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34420 };
34421
34422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34424 if (SWIG_arg_fail(1)) SWIG_fail;
34425 {
34426 arg2 = static_cast<int >(SWIG_As_int(obj1));
34427 if (SWIG_arg_fail(2)) SWIG_fail;
34428 }
34429 {
34430 arg3 = wxString_in_helper(obj2);
34431 if (arg3 == NULL) SWIG_fail;
34432 temp3 = true;
34433 }
34434 if (obj3) {
34435 {
34436 arg4 = wxString_in_helper(obj3);
34437 if (arg4 == NULL) SWIG_fail;
34438 temp4 = true;
34439 }
34440 }
34441 {
34442 PyThreadState* __tstate = wxPyBeginAllowThreads();
34443 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34444
34445 wxPyEndAllowThreads(__tstate);
34446 if (PyErr_Occurred()) SWIG_fail;
34447 }
34448 {
34449 resultobj = wxPyMake_wxObject(result, (bool)0);
34450 }
34451 {
34452 if (temp3)
34453 delete arg3;
34454 }
34455 {
34456 if (temp4)
34457 delete arg4;
34458 }
34459 return resultobj;
34460 fail:
34461 {
34462 if (temp3)
34463 delete arg3;
34464 }
34465 {
34466 if (temp4)
34467 delete arg4;
34468 }
34469 return NULL;
34470 }
34471
34472
34473 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34474 PyObject *resultobj = NULL;
34475 wxMenu *arg1 = (wxMenu *) 0 ;
34476 int arg2 ;
34477 wxString *arg3 = 0 ;
34478 wxString const &arg4_defvalue = wxPyEmptyString ;
34479 wxString *arg4 = (wxString *) &arg4_defvalue ;
34480 wxMenuItem *result;
34481 bool temp3 = false ;
34482 bool temp4 = false ;
34483 PyObject * obj0 = 0 ;
34484 PyObject * obj1 = 0 ;
34485 PyObject * obj2 = 0 ;
34486 PyObject * obj3 = 0 ;
34487 char *kwnames[] = {
34488 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34489 };
34490
34491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34493 if (SWIG_arg_fail(1)) SWIG_fail;
34494 {
34495 arg2 = static_cast<int >(SWIG_As_int(obj1));
34496 if (SWIG_arg_fail(2)) SWIG_fail;
34497 }
34498 {
34499 arg3 = wxString_in_helper(obj2);
34500 if (arg3 == NULL) SWIG_fail;
34501 temp3 = true;
34502 }
34503 if (obj3) {
34504 {
34505 arg4 = wxString_in_helper(obj3);
34506 if (arg4 == NULL) SWIG_fail;
34507 temp4 = true;
34508 }
34509 }
34510 {
34511 PyThreadState* __tstate = wxPyBeginAllowThreads();
34512 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34513
34514 wxPyEndAllowThreads(__tstate);
34515 if (PyErr_Occurred()) SWIG_fail;
34516 }
34517 {
34518 resultobj = wxPyMake_wxObject(result, (bool)0);
34519 }
34520 {
34521 if (temp3)
34522 delete arg3;
34523 }
34524 {
34525 if (temp4)
34526 delete arg4;
34527 }
34528 return resultobj;
34529 fail:
34530 {
34531 if (temp3)
34532 delete arg3;
34533 }
34534 {
34535 if (temp4)
34536 delete arg4;
34537 }
34538 return NULL;
34539 }
34540
34541
34542 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34543 PyObject *resultobj = NULL;
34544 wxMenu *arg1 = (wxMenu *) 0 ;
34545 int arg2 ;
34546 wxString *arg3 = 0 ;
34547 wxMenu *arg4 = (wxMenu *) 0 ;
34548 wxString const &arg5_defvalue = wxPyEmptyString ;
34549 wxString *arg5 = (wxString *) &arg5_defvalue ;
34550 wxMenuItem *result;
34551 bool temp3 = false ;
34552 bool temp5 = false ;
34553 PyObject * obj0 = 0 ;
34554 PyObject * obj1 = 0 ;
34555 PyObject * obj2 = 0 ;
34556 PyObject * obj3 = 0 ;
34557 PyObject * obj4 = 0 ;
34558 char *kwnames[] = {
34559 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34560 };
34561
34562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34564 if (SWIG_arg_fail(1)) SWIG_fail;
34565 {
34566 arg2 = static_cast<int >(SWIG_As_int(obj1));
34567 if (SWIG_arg_fail(2)) SWIG_fail;
34568 }
34569 {
34570 arg3 = wxString_in_helper(obj2);
34571 if (arg3 == NULL) SWIG_fail;
34572 temp3 = true;
34573 }
34574 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34575 if (SWIG_arg_fail(4)) SWIG_fail;
34576 if (obj4) {
34577 {
34578 arg5 = wxString_in_helper(obj4);
34579 if (arg5 == NULL) SWIG_fail;
34580 temp5 = true;
34581 }
34582 }
34583 {
34584 PyThreadState* __tstate = wxPyBeginAllowThreads();
34585 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
34586
34587 wxPyEndAllowThreads(__tstate);
34588 if (PyErr_Occurred()) SWIG_fail;
34589 }
34590 {
34591 resultobj = wxPyMake_wxObject(result, (bool)0);
34592 }
34593 {
34594 if (temp3)
34595 delete arg3;
34596 }
34597 {
34598 if (temp5)
34599 delete arg5;
34600 }
34601 return resultobj;
34602 fail:
34603 {
34604 if (temp3)
34605 delete arg3;
34606 }
34607 {
34608 if (temp5)
34609 delete arg5;
34610 }
34611 return NULL;
34612 }
34613
34614
34615 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34616 PyObject *resultobj = NULL;
34617 wxMenu *arg1 = (wxMenu *) 0 ;
34618 int arg2 ;
34619 wxMenuItem *result;
34620 PyObject * obj0 = 0 ;
34621 PyObject * obj1 = 0 ;
34622 char *kwnames[] = {
34623 (char *) "self",(char *) "id", NULL
34624 };
34625
34626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
34627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34628 if (SWIG_arg_fail(1)) SWIG_fail;
34629 {
34630 arg2 = static_cast<int >(SWIG_As_int(obj1));
34631 if (SWIG_arg_fail(2)) SWIG_fail;
34632 }
34633 {
34634 PyThreadState* __tstate = wxPyBeginAllowThreads();
34635 result = (wxMenuItem *)(arg1)->Remove(arg2);
34636
34637 wxPyEndAllowThreads(__tstate);
34638 if (PyErr_Occurred()) SWIG_fail;
34639 }
34640 {
34641 resultobj = wxPyMake_wxObject(result, (bool)0);
34642 }
34643 return resultobj;
34644 fail:
34645 return NULL;
34646 }
34647
34648
34649 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
34650 PyObject *resultobj = NULL;
34651 wxMenu *arg1 = (wxMenu *) 0 ;
34652 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34653 wxMenuItem *result;
34654 PyObject * obj0 = 0 ;
34655 PyObject * obj1 = 0 ;
34656 char *kwnames[] = {
34657 (char *) "self",(char *) "item", NULL
34658 };
34659
34660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
34661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34662 if (SWIG_arg_fail(1)) SWIG_fail;
34663 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34664 if (SWIG_arg_fail(2)) SWIG_fail;
34665 {
34666 PyThreadState* __tstate = wxPyBeginAllowThreads();
34667 result = (wxMenuItem *)(arg1)->Remove(arg2);
34668
34669 wxPyEndAllowThreads(__tstate);
34670 if (PyErr_Occurred()) SWIG_fail;
34671 }
34672 {
34673 resultobj = wxPyMake_wxObject(result, (bool)0);
34674 }
34675 return resultobj;
34676 fail:
34677 return NULL;
34678 }
34679
34680
34681 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
34682 PyObject *resultobj = NULL;
34683 wxMenu *arg1 = (wxMenu *) 0 ;
34684 int arg2 ;
34685 bool result;
34686 PyObject * obj0 = 0 ;
34687 PyObject * obj1 = 0 ;
34688 char *kwnames[] = {
34689 (char *) "self",(char *) "id", NULL
34690 };
34691
34692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
34693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34694 if (SWIG_arg_fail(1)) SWIG_fail;
34695 {
34696 arg2 = static_cast<int >(SWIG_As_int(obj1));
34697 if (SWIG_arg_fail(2)) SWIG_fail;
34698 }
34699 {
34700 PyThreadState* __tstate = wxPyBeginAllowThreads();
34701 result = (bool)(arg1)->Delete(arg2);
34702
34703 wxPyEndAllowThreads(__tstate);
34704 if (PyErr_Occurred()) SWIG_fail;
34705 }
34706 {
34707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34708 }
34709 return resultobj;
34710 fail:
34711 return NULL;
34712 }
34713
34714
34715 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
34716 PyObject *resultobj = NULL;
34717 wxMenu *arg1 = (wxMenu *) 0 ;
34718 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34719 bool result;
34720 PyObject * obj0 = 0 ;
34721 PyObject * obj1 = 0 ;
34722 char *kwnames[] = {
34723 (char *) "self",(char *) "item", NULL
34724 };
34725
34726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
34727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34728 if (SWIG_arg_fail(1)) SWIG_fail;
34729 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34730 if (SWIG_arg_fail(2)) SWIG_fail;
34731 {
34732 PyThreadState* __tstate = wxPyBeginAllowThreads();
34733 result = (bool)(arg1)->Delete(arg2);
34734
34735 wxPyEndAllowThreads(__tstate);
34736 if (PyErr_Occurred()) SWIG_fail;
34737 }
34738 {
34739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34740 }
34741 return resultobj;
34742 fail:
34743 return NULL;
34744 }
34745
34746
34747 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
34748 PyObject *resultobj = NULL;
34749 wxMenu *arg1 = (wxMenu *) 0 ;
34750 PyObject * obj0 = 0 ;
34751 char *kwnames[] = {
34752 (char *) "self", NULL
34753 };
34754
34755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
34756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34757 if (SWIG_arg_fail(1)) SWIG_fail;
34758 {
34759 PyThreadState* __tstate = wxPyBeginAllowThreads();
34760 wxMenu_Destroy(arg1);
34761
34762 wxPyEndAllowThreads(__tstate);
34763 if (PyErr_Occurred()) SWIG_fail;
34764 }
34765 Py_INCREF(Py_None); resultobj = Py_None;
34766 return resultobj;
34767 fail:
34768 return NULL;
34769 }
34770
34771
34772 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
34773 PyObject *resultobj = NULL;
34774 wxMenu *arg1 = (wxMenu *) 0 ;
34775 int arg2 ;
34776 bool result;
34777 PyObject * obj0 = 0 ;
34778 PyObject * obj1 = 0 ;
34779 char *kwnames[] = {
34780 (char *) "self",(char *) "id", NULL
34781 };
34782
34783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
34784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34785 if (SWIG_arg_fail(1)) SWIG_fail;
34786 {
34787 arg2 = static_cast<int >(SWIG_As_int(obj1));
34788 if (SWIG_arg_fail(2)) SWIG_fail;
34789 }
34790 {
34791 PyThreadState* __tstate = wxPyBeginAllowThreads();
34792 result = (bool)(arg1)->Destroy(arg2);
34793
34794 wxPyEndAllowThreads(__tstate);
34795 if (PyErr_Occurred()) SWIG_fail;
34796 }
34797 {
34798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34799 }
34800 return resultobj;
34801 fail:
34802 return NULL;
34803 }
34804
34805
34806 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34807 PyObject *resultobj = NULL;
34808 wxMenu *arg1 = (wxMenu *) 0 ;
34809 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34810 bool result;
34811 PyObject * obj0 = 0 ;
34812 PyObject * obj1 = 0 ;
34813 char *kwnames[] = {
34814 (char *) "self",(char *) "item", NULL
34815 };
34816
34817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34819 if (SWIG_arg_fail(1)) SWIG_fail;
34820 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34821 if (SWIG_arg_fail(2)) SWIG_fail;
34822 {
34823 PyThreadState* __tstate = wxPyBeginAllowThreads();
34824 result = (bool)(arg1)->Destroy(arg2);
34825
34826 wxPyEndAllowThreads(__tstate);
34827 if (PyErr_Occurred()) SWIG_fail;
34828 }
34829 {
34830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34831 }
34832 return resultobj;
34833 fail:
34834 return NULL;
34835 }
34836
34837
34838 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34839 PyObject *resultobj = NULL;
34840 wxMenu *arg1 = (wxMenu *) 0 ;
34841 size_t result;
34842 PyObject * obj0 = 0 ;
34843 char *kwnames[] = {
34844 (char *) "self", NULL
34845 };
34846
34847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34849 if (SWIG_arg_fail(1)) SWIG_fail;
34850 {
34851 PyThreadState* __tstate = wxPyBeginAllowThreads();
34852 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34853
34854 wxPyEndAllowThreads(__tstate);
34855 if (PyErr_Occurred()) SWIG_fail;
34856 }
34857 {
34858 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
34859 }
34860 return resultobj;
34861 fail:
34862 return NULL;
34863 }
34864
34865
34866 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34867 PyObject *resultobj = NULL;
34868 wxMenu *arg1 = (wxMenu *) 0 ;
34869 PyObject *result;
34870 PyObject * obj0 = 0 ;
34871 char *kwnames[] = {
34872 (char *) "self", NULL
34873 };
34874
34875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34877 if (SWIG_arg_fail(1)) SWIG_fail;
34878 {
34879 PyThreadState* __tstate = wxPyBeginAllowThreads();
34880 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34881
34882 wxPyEndAllowThreads(__tstate);
34883 if (PyErr_Occurred()) SWIG_fail;
34884 }
34885 resultobj = result;
34886 return resultobj;
34887 fail:
34888 return NULL;
34889 }
34890
34891
34892 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34893 PyObject *resultobj = NULL;
34894 wxMenu *arg1 = (wxMenu *) 0 ;
34895 wxString *arg2 = 0 ;
34896 int result;
34897 bool temp2 = false ;
34898 PyObject * obj0 = 0 ;
34899 PyObject * obj1 = 0 ;
34900 char *kwnames[] = {
34901 (char *) "self",(char *) "item", NULL
34902 };
34903
34904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34906 if (SWIG_arg_fail(1)) SWIG_fail;
34907 {
34908 arg2 = wxString_in_helper(obj1);
34909 if (arg2 == NULL) SWIG_fail;
34910 temp2 = true;
34911 }
34912 {
34913 PyThreadState* __tstate = wxPyBeginAllowThreads();
34914 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34915
34916 wxPyEndAllowThreads(__tstate);
34917 if (PyErr_Occurred()) SWIG_fail;
34918 }
34919 {
34920 resultobj = SWIG_From_int(static_cast<int >(result));
34921 }
34922 {
34923 if (temp2)
34924 delete arg2;
34925 }
34926 return resultobj;
34927 fail:
34928 {
34929 if (temp2)
34930 delete arg2;
34931 }
34932 return NULL;
34933 }
34934
34935
34936 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34937 PyObject *resultobj = NULL;
34938 wxMenu *arg1 = (wxMenu *) 0 ;
34939 int arg2 ;
34940 wxMenuItem *result;
34941 PyObject * obj0 = 0 ;
34942 PyObject * obj1 = 0 ;
34943 char *kwnames[] = {
34944 (char *) "self",(char *) "id", NULL
34945 };
34946
34947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34949 if (SWIG_arg_fail(1)) SWIG_fail;
34950 {
34951 arg2 = static_cast<int >(SWIG_As_int(obj1));
34952 if (SWIG_arg_fail(2)) SWIG_fail;
34953 }
34954 {
34955 PyThreadState* __tstate = wxPyBeginAllowThreads();
34956 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34957
34958 wxPyEndAllowThreads(__tstate);
34959 if (PyErr_Occurred()) SWIG_fail;
34960 }
34961 {
34962 resultobj = wxPyMake_wxObject(result, (bool)0);
34963 }
34964 return resultobj;
34965 fail:
34966 return NULL;
34967 }
34968
34969
34970 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34971 PyObject *resultobj = NULL;
34972 wxMenu *arg1 = (wxMenu *) 0 ;
34973 size_t arg2 ;
34974 wxMenuItem *result;
34975 PyObject * obj0 = 0 ;
34976 PyObject * obj1 = 0 ;
34977 char *kwnames[] = {
34978 (char *) "self",(char *) "position", NULL
34979 };
34980
34981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34983 if (SWIG_arg_fail(1)) SWIG_fail;
34984 {
34985 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
34986 if (SWIG_arg_fail(2)) SWIG_fail;
34987 }
34988 {
34989 PyThreadState* __tstate = wxPyBeginAllowThreads();
34990 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34991
34992 wxPyEndAllowThreads(__tstate);
34993 if (PyErr_Occurred()) SWIG_fail;
34994 }
34995 {
34996 resultobj = wxPyMake_wxObject(result, (bool)0);
34997 }
34998 return resultobj;
34999 fail:
35000 return NULL;
35001 }
35002
35003
35004 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35005 PyObject *resultobj = NULL;
35006 wxMenu *arg1 = (wxMenu *) 0 ;
35007 int arg2 ;
35008 bool arg3 ;
35009 PyObject * obj0 = 0 ;
35010 PyObject * obj1 = 0 ;
35011 PyObject * obj2 = 0 ;
35012 char *kwnames[] = {
35013 (char *) "self",(char *) "id",(char *) "enable", NULL
35014 };
35015
35016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35018 if (SWIG_arg_fail(1)) SWIG_fail;
35019 {
35020 arg2 = static_cast<int >(SWIG_As_int(obj1));
35021 if (SWIG_arg_fail(2)) SWIG_fail;
35022 }
35023 {
35024 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
35025 if (SWIG_arg_fail(3)) SWIG_fail;
35026 }
35027 {
35028 PyThreadState* __tstate = wxPyBeginAllowThreads();
35029 (arg1)->Enable(arg2,arg3);
35030
35031 wxPyEndAllowThreads(__tstate);
35032 if (PyErr_Occurred()) SWIG_fail;
35033 }
35034 Py_INCREF(Py_None); resultobj = Py_None;
35035 return resultobj;
35036 fail:
35037 return NULL;
35038 }
35039
35040
35041 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35042 PyObject *resultobj = NULL;
35043 wxMenu *arg1 = (wxMenu *) 0 ;
35044 int arg2 ;
35045 bool result;
35046 PyObject * obj0 = 0 ;
35047 PyObject * obj1 = 0 ;
35048 char *kwnames[] = {
35049 (char *) "self",(char *) "id", NULL
35050 };
35051
35052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35054 if (SWIG_arg_fail(1)) SWIG_fail;
35055 {
35056 arg2 = static_cast<int >(SWIG_As_int(obj1));
35057 if (SWIG_arg_fail(2)) SWIG_fail;
35058 }
35059 {
35060 PyThreadState* __tstate = wxPyBeginAllowThreads();
35061 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
35062
35063 wxPyEndAllowThreads(__tstate);
35064 if (PyErr_Occurred()) SWIG_fail;
35065 }
35066 {
35067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35068 }
35069 return resultobj;
35070 fail:
35071 return NULL;
35072 }
35073
35074
35075 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35076 PyObject *resultobj = NULL;
35077 wxMenu *arg1 = (wxMenu *) 0 ;
35078 int arg2 ;
35079 bool arg3 ;
35080 PyObject * obj0 = 0 ;
35081 PyObject * obj1 = 0 ;
35082 PyObject * obj2 = 0 ;
35083 char *kwnames[] = {
35084 (char *) "self",(char *) "id",(char *) "check", NULL
35085 };
35086
35087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35089 if (SWIG_arg_fail(1)) SWIG_fail;
35090 {
35091 arg2 = static_cast<int >(SWIG_As_int(obj1));
35092 if (SWIG_arg_fail(2)) SWIG_fail;
35093 }
35094 {
35095 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
35096 if (SWIG_arg_fail(3)) SWIG_fail;
35097 }
35098 {
35099 PyThreadState* __tstate = wxPyBeginAllowThreads();
35100 (arg1)->Check(arg2,arg3);
35101
35102 wxPyEndAllowThreads(__tstate);
35103 if (PyErr_Occurred()) SWIG_fail;
35104 }
35105 Py_INCREF(Py_None); resultobj = Py_None;
35106 return resultobj;
35107 fail:
35108 return NULL;
35109 }
35110
35111
35112 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35113 PyObject *resultobj = NULL;
35114 wxMenu *arg1 = (wxMenu *) 0 ;
35115 int arg2 ;
35116 bool result;
35117 PyObject * obj0 = 0 ;
35118 PyObject * obj1 = 0 ;
35119 char *kwnames[] = {
35120 (char *) "self",(char *) "id", NULL
35121 };
35122
35123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35125 if (SWIG_arg_fail(1)) SWIG_fail;
35126 {
35127 arg2 = static_cast<int >(SWIG_As_int(obj1));
35128 if (SWIG_arg_fail(2)) SWIG_fail;
35129 }
35130 {
35131 PyThreadState* __tstate = wxPyBeginAllowThreads();
35132 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
35133
35134 wxPyEndAllowThreads(__tstate);
35135 if (PyErr_Occurred()) SWIG_fail;
35136 }
35137 {
35138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35139 }
35140 return resultobj;
35141 fail:
35142 return NULL;
35143 }
35144
35145
35146 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35147 PyObject *resultobj = NULL;
35148 wxMenu *arg1 = (wxMenu *) 0 ;
35149 int arg2 ;
35150 wxString *arg3 = 0 ;
35151 bool temp3 = false ;
35152 PyObject * obj0 = 0 ;
35153 PyObject * obj1 = 0 ;
35154 PyObject * obj2 = 0 ;
35155 char *kwnames[] = {
35156 (char *) "self",(char *) "id",(char *) "label", NULL
35157 };
35158
35159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35161 if (SWIG_arg_fail(1)) SWIG_fail;
35162 {
35163 arg2 = static_cast<int >(SWIG_As_int(obj1));
35164 if (SWIG_arg_fail(2)) SWIG_fail;
35165 }
35166 {
35167 arg3 = wxString_in_helper(obj2);
35168 if (arg3 == NULL) SWIG_fail;
35169 temp3 = true;
35170 }
35171 {
35172 PyThreadState* __tstate = wxPyBeginAllowThreads();
35173 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35174
35175 wxPyEndAllowThreads(__tstate);
35176 if (PyErr_Occurred()) SWIG_fail;
35177 }
35178 Py_INCREF(Py_None); resultobj = Py_None;
35179 {
35180 if (temp3)
35181 delete arg3;
35182 }
35183 return resultobj;
35184 fail:
35185 {
35186 if (temp3)
35187 delete arg3;
35188 }
35189 return NULL;
35190 }
35191
35192
35193 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35194 PyObject *resultobj = NULL;
35195 wxMenu *arg1 = (wxMenu *) 0 ;
35196 int arg2 ;
35197 wxString result;
35198 PyObject * obj0 = 0 ;
35199 PyObject * obj1 = 0 ;
35200 char *kwnames[] = {
35201 (char *) "self",(char *) "id", NULL
35202 };
35203
35204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35206 if (SWIG_arg_fail(1)) SWIG_fail;
35207 {
35208 arg2 = static_cast<int >(SWIG_As_int(obj1));
35209 if (SWIG_arg_fail(2)) SWIG_fail;
35210 }
35211 {
35212 PyThreadState* __tstate = wxPyBeginAllowThreads();
35213 result = ((wxMenu const *)arg1)->GetLabel(arg2);
35214
35215 wxPyEndAllowThreads(__tstate);
35216 if (PyErr_Occurred()) SWIG_fail;
35217 }
35218 {
35219 #if wxUSE_UNICODE
35220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35221 #else
35222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35223 #endif
35224 }
35225 return resultobj;
35226 fail:
35227 return NULL;
35228 }
35229
35230
35231 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35232 PyObject *resultobj = NULL;
35233 wxMenu *arg1 = (wxMenu *) 0 ;
35234 int arg2 ;
35235 wxString *arg3 = 0 ;
35236 bool temp3 = false ;
35237 PyObject * obj0 = 0 ;
35238 PyObject * obj1 = 0 ;
35239 PyObject * obj2 = 0 ;
35240 char *kwnames[] = {
35241 (char *) "self",(char *) "id",(char *) "helpString", NULL
35242 };
35243
35244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35245 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35246 if (SWIG_arg_fail(1)) SWIG_fail;
35247 {
35248 arg2 = static_cast<int >(SWIG_As_int(obj1));
35249 if (SWIG_arg_fail(2)) SWIG_fail;
35250 }
35251 {
35252 arg3 = wxString_in_helper(obj2);
35253 if (arg3 == NULL) SWIG_fail;
35254 temp3 = true;
35255 }
35256 {
35257 PyThreadState* __tstate = wxPyBeginAllowThreads();
35258 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35259
35260 wxPyEndAllowThreads(__tstate);
35261 if (PyErr_Occurred()) SWIG_fail;
35262 }
35263 Py_INCREF(Py_None); resultobj = Py_None;
35264 {
35265 if (temp3)
35266 delete arg3;
35267 }
35268 return resultobj;
35269 fail:
35270 {
35271 if (temp3)
35272 delete arg3;
35273 }
35274 return NULL;
35275 }
35276
35277
35278 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35279 PyObject *resultobj = NULL;
35280 wxMenu *arg1 = (wxMenu *) 0 ;
35281 int arg2 ;
35282 wxString result;
35283 PyObject * obj0 = 0 ;
35284 PyObject * obj1 = 0 ;
35285 char *kwnames[] = {
35286 (char *) "self",(char *) "id", NULL
35287 };
35288
35289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35291 if (SWIG_arg_fail(1)) SWIG_fail;
35292 {
35293 arg2 = static_cast<int >(SWIG_As_int(obj1));
35294 if (SWIG_arg_fail(2)) SWIG_fail;
35295 }
35296 {
35297 PyThreadState* __tstate = wxPyBeginAllowThreads();
35298 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
35299
35300 wxPyEndAllowThreads(__tstate);
35301 if (PyErr_Occurred()) SWIG_fail;
35302 }
35303 {
35304 #if wxUSE_UNICODE
35305 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35306 #else
35307 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35308 #endif
35309 }
35310 return resultobj;
35311 fail:
35312 return NULL;
35313 }
35314
35315
35316 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35317 PyObject *resultobj = NULL;
35318 wxMenu *arg1 = (wxMenu *) 0 ;
35319 wxString *arg2 = 0 ;
35320 bool temp2 = false ;
35321 PyObject * obj0 = 0 ;
35322 PyObject * obj1 = 0 ;
35323 char *kwnames[] = {
35324 (char *) "self",(char *) "title", NULL
35325 };
35326
35327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
35328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35329 if (SWIG_arg_fail(1)) SWIG_fail;
35330 {
35331 arg2 = wxString_in_helper(obj1);
35332 if (arg2 == NULL) SWIG_fail;
35333 temp2 = true;
35334 }
35335 {
35336 PyThreadState* __tstate = wxPyBeginAllowThreads();
35337 (arg1)->SetTitle((wxString const &)*arg2);
35338
35339 wxPyEndAllowThreads(__tstate);
35340 if (PyErr_Occurred()) SWIG_fail;
35341 }
35342 Py_INCREF(Py_None); resultobj = Py_None;
35343 {
35344 if (temp2)
35345 delete arg2;
35346 }
35347 return resultobj;
35348 fail:
35349 {
35350 if (temp2)
35351 delete arg2;
35352 }
35353 return NULL;
35354 }
35355
35356
35357 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35358 PyObject *resultobj = NULL;
35359 wxMenu *arg1 = (wxMenu *) 0 ;
35360 wxString result;
35361 PyObject * obj0 = 0 ;
35362 char *kwnames[] = {
35363 (char *) "self", NULL
35364 };
35365
35366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
35367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35368 if (SWIG_arg_fail(1)) SWIG_fail;
35369 {
35370 PyThreadState* __tstate = wxPyBeginAllowThreads();
35371 result = ((wxMenu const *)arg1)->GetTitle();
35372
35373 wxPyEndAllowThreads(__tstate);
35374 if (PyErr_Occurred()) SWIG_fail;
35375 }
35376 {
35377 #if wxUSE_UNICODE
35378 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35379 #else
35380 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35381 #endif
35382 }
35383 return resultobj;
35384 fail:
35385 return NULL;
35386 }
35387
35388
35389 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35390 PyObject *resultobj = NULL;
35391 wxMenu *arg1 = (wxMenu *) 0 ;
35392 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
35393 PyObject * obj0 = 0 ;
35394 PyObject * obj1 = 0 ;
35395 char *kwnames[] = {
35396 (char *) "self",(char *) "handler", NULL
35397 };
35398
35399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
35400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35401 if (SWIG_arg_fail(1)) SWIG_fail;
35402 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35403 if (SWIG_arg_fail(2)) SWIG_fail;
35404 {
35405 PyThreadState* __tstate = wxPyBeginAllowThreads();
35406 (arg1)->SetEventHandler(arg2);
35407
35408 wxPyEndAllowThreads(__tstate);
35409 if (PyErr_Occurred()) SWIG_fail;
35410 }
35411 Py_INCREF(Py_None); resultobj = Py_None;
35412 return resultobj;
35413 fail:
35414 return NULL;
35415 }
35416
35417
35418 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35419 PyObject *resultobj = NULL;
35420 wxMenu *arg1 = (wxMenu *) 0 ;
35421 wxEvtHandler *result;
35422 PyObject * obj0 = 0 ;
35423 char *kwnames[] = {
35424 (char *) "self", NULL
35425 };
35426
35427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
35428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35429 if (SWIG_arg_fail(1)) SWIG_fail;
35430 {
35431 PyThreadState* __tstate = wxPyBeginAllowThreads();
35432 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
35433
35434 wxPyEndAllowThreads(__tstate);
35435 if (PyErr_Occurred()) SWIG_fail;
35436 }
35437 {
35438 resultobj = wxPyMake_wxObject(result, 0);
35439 }
35440 return resultobj;
35441 fail:
35442 return NULL;
35443 }
35444
35445
35446 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35447 PyObject *resultobj = NULL;
35448 wxMenu *arg1 = (wxMenu *) 0 ;
35449 wxWindow *arg2 = (wxWindow *) 0 ;
35450 PyObject * obj0 = 0 ;
35451 PyObject * obj1 = 0 ;
35452 char *kwnames[] = {
35453 (char *) "self",(char *) "win", NULL
35454 };
35455
35456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
35457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35458 if (SWIG_arg_fail(1)) SWIG_fail;
35459 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
35460 if (SWIG_arg_fail(2)) SWIG_fail;
35461 {
35462 PyThreadState* __tstate = wxPyBeginAllowThreads();
35463 (arg1)->SetInvokingWindow(arg2);
35464
35465 wxPyEndAllowThreads(__tstate);
35466 if (PyErr_Occurred()) SWIG_fail;
35467 }
35468 Py_INCREF(Py_None); resultobj = Py_None;
35469 return resultobj;
35470 fail:
35471 return NULL;
35472 }
35473
35474
35475 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35476 PyObject *resultobj = NULL;
35477 wxMenu *arg1 = (wxMenu *) 0 ;
35478 wxWindow *result;
35479 PyObject * obj0 = 0 ;
35480 char *kwnames[] = {
35481 (char *) "self", NULL
35482 };
35483
35484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
35485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35486 if (SWIG_arg_fail(1)) SWIG_fail;
35487 {
35488 PyThreadState* __tstate = wxPyBeginAllowThreads();
35489 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
35490
35491 wxPyEndAllowThreads(__tstate);
35492 if (PyErr_Occurred()) SWIG_fail;
35493 }
35494 {
35495 resultobj = wxPyMake_wxObject(result, 0);
35496 }
35497 return resultobj;
35498 fail:
35499 return NULL;
35500 }
35501
35502
35503 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
35504 PyObject *resultobj = NULL;
35505 wxMenu *arg1 = (wxMenu *) 0 ;
35506 long result;
35507 PyObject * obj0 = 0 ;
35508 char *kwnames[] = {
35509 (char *) "self", NULL
35510 };
35511
35512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
35513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35514 if (SWIG_arg_fail(1)) SWIG_fail;
35515 {
35516 PyThreadState* __tstate = wxPyBeginAllowThreads();
35517 result = (long)((wxMenu const *)arg1)->GetStyle();
35518
35519 wxPyEndAllowThreads(__tstate);
35520 if (PyErr_Occurred()) SWIG_fail;
35521 }
35522 {
35523 resultobj = SWIG_From_long(static_cast<long >(result));
35524 }
35525 return resultobj;
35526 fail:
35527 return NULL;
35528 }
35529
35530
35531 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
35532 PyObject *resultobj = NULL;
35533 wxMenu *arg1 = (wxMenu *) 0 ;
35534 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
35535 PyObject * obj0 = 0 ;
35536 PyObject * obj1 = 0 ;
35537 char *kwnames[] = {
35538 (char *) "self",(char *) "source", NULL
35539 };
35540
35541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
35542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35543 if (SWIG_arg_fail(1)) SWIG_fail;
35544 if (obj1) {
35545 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35546 if (SWIG_arg_fail(2)) SWIG_fail;
35547 }
35548 {
35549 PyThreadState* __tstate = wxPyBeginAllowThreads();
35550 (arg1)->UpdateUI(arg2);
35551
35552 wxPyEndAllowThreads(__tstate);
35553 if (PyErr_Occurred()) SWIG_fail;
35554 }
35555 Py_INCREF(Py_None); resultobj = Py_None;
35556 return resultobj;
35557 fail:
35558 return NULL;
35559 }
35560
35561
35562 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35563 PyObject *resultobj = NULL;
35564 wxMenu *arg1 = (wxMenu *) 0 ;
35565 wxMenuBar *result;
35566 PyObject * obj0 = 0 ;
35567 char *kwnames[] = {
35568 (char *) "self", NULL
35569 };
35570
35571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
35572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35573 if (SWIG_arg_fail(1)) SWIG_fail;
35574 {
35575 PyThreadState* __tstate = wxPyBeginAllowThreads();
35576 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
35577
35578 wxPyEndAllowThreads(__tstate);
35579 if (PyErr_Occurred()) SWIG_fail;
35580 }
35581 {
35582 resultobj = wxPyMake_wxObject(result, (bool)0);
35583 }
35584 return resultobj;
35585 fail:
35586 return NULL;
35587 }
35588
35589
35590 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35591 PyObject *resultobj = NULL;
35592 wxMenu *arg1 = (wxMenu *) 0 ;
35593 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
35594 PyObject * obj0 = 0 ;
35595 PyObject * obj1 = 0 ;
35596 char *kwnames[] = {
35597 (char *) "self",(char *) "menubar", NULL
35598 };
35599
35600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
35601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35602 if (SWIG_arg_fail(1)) SWIG_fail;
35603 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
35604 if (SWIG_arg_fail(2)) SWIG_fail;
35605 {
35606 PyThreadState* __tstate = wxPyBeginAllowThreads();
35607 (arg1)->Attach(arg2);
35608
35609 wxPyEndAllowThreads(__tstate);
35610 if (PyErr_Occurred()) SWIG_fail;
35611 }
35612 Py_INCREF(Py_None); resultobj = Py_None;
35613 return resultobj;
35614 fail:
35615 return NULL;
35616 }
35617
35618
35619 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35620 PyObject *resultobj = NULL;
35621 wxMenu *arg1 = (wxMenu *) 0 ;
35622 PyObject * obj0 = 0 ;
35623 char *kwnames[] = {
35624 (char *) "self", NULL
35625 };
35626
35627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
35628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35629 if (SWIG_arg_fail(1)) SWIG_fail;
35630 {
35631 PyThreadState* __tstate = wxPyBeginAllowThreads();
35632 (arg1)->Detach();
35633
35634 wxPyEndAllowThreads(__tstate);
35635 if (PyErr_Occurred()) SWIG_fail;
35636 }
35637 Py_INCREF(Py_None); resultobj = Py_None;
35638 return resultobj;
35639 fail:
35640 return NULL;
35641 }
35642
35643
35644 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35645 PyObject *resultobj = NULL;
35646 wxMenu *arg1 = (wxMenu *) 0 ;
35647 bool result;
35648 PyObject * obj0 = 0 ;
35649 char *kwnames[] = {
35650 (char *) "self", NULL
35651 };
35652
35653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
35654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35655 if (SWIG_arg_fail(1)) SWIG_fail;
35656 {
35657 PyThreadState* __tstate = wxPyBeginAllowThreads();
35658 result = (bool)((wxMenu const *)arg1)->IsAttached();
35659
35660 wxPyEndAllowThreads(__tstate);
35661 if (PyErr_Occurred()) SWIG_fail;
35662 }
35663 {
35664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35665 }
35666 return resultobj;
35667 fail:
35668 return NULL;
35669 }
35670
35671
35672 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35673 PyObject *resultobj = NULL;
35674 wxMenu *arg1 = (wxMenu *) 0 ;
35675 wxMenu *arg2 = (wxMenu *) 0 ;
35676 PyObject * obj0 = 0 ;
35677 PyObject * obj1 = 0 ;
35678 char *kwnames[] = {
35679 (char *) "self",(char *) "parent", NULL
35680 };
35681
35682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
35683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35684 if (SWIG_arg_fail(1)) SWIG_fail;
35685 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35686 if (SWIG_arg_fail(2)) SWIG_fail;
35687 {
35688 PyThreadState* __tstate = wxPyBeginAllowThreads();
35689 (arg1)->SetParent(arg2);
35690
35691 wxPyEndAllowThreads(__tstate);
35692 if (PyErr_Occurred()) SWIG_fail;
35693 }
35694 Py_INCREF(Py_None); resultobj = Py_None;
35695 return resultobj;
35696 fail:
35697 return NULL;
35698 }
35699
35700
35701 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35702 PyObject *resultobj = NULL;
35703 wxMenu *arg1 = (wxMenu *) 0 ;
35704 wxMenu *result;
35705 PyObject * obj0 = 0 ;
35706 char *kwnames[] = {
35707 (char *) "self", NULL
35708 };
35709
35710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
35711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35712 if (SWIG_arg_fail(1)) SWIG_fail;
35713 {
35714 PyThreadState* __tstate = wxPyBeginAllowThreads();
35715 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
35716
35717 wxPyEndAllowThreads(__tstate);
35718 if (PyErr_Occurred()) SWIG_fail;
35719 }
35720 {
35721 resultobj = wxPyMake_wxObject(result, 0);
35722 }
35723 return resultobj;
35724 fail:
35725 return NULL;
35726 }
35727
35728
35729 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
35730 PyObject *obj;
35731 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35732 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
35733 Py_INCREF(obj);
35734 return Py_BuildValue((char *)"");
35735 }
35736 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35737 PyObject *resultobj = NULL;
35738 long arg1 = (long) 0 ;
35739 wxMenuBar *result;
35740 PyObject * obj0 = 0 ;
35741 char *kwnames[] = {
35742 (char *) "style", NULL
35743 };
35744
35745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
35746 if (obj0) {
35747 {
35748 arg1 = static_cast<long >(SWIG_As_long(obj0));
35749 if (SWIG_arg_fail(1)) SWIG_fail;
35750 }
35751 }
35752 {
35753 if (!wxPyCheckForApp()) SWIG_fail;
35754 PyThreadState* __tstate = wxPyBeginAllowThreads();
35755 result = (wxMenuBar *)new wxMenuBar(arg1);
35756
35757 wxPyEndAllowThreads(__tstate);
35758 if (PyErr_Occurred()) SWIG_fail;
35759 }
35760 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
35761 return resultobj;
35762 fail:
35763 return NULL;
35764 }
35765
35766
35767 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
35768 PyObject *resultobj = NULL;
35769 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35770 wxMenu *arg2 = (wxMenu *) 0 ;
35771 wxString *arg3 = 0 ;
35772 bool result;
35773 bool temp3 = false ;
35774 PyObject * obj0 = 0 ;
35775 PyObject * obj1 = 0 ;
35776 PyObject * obj2 = 0 ;
35777 char *kwnames[] = {
35778 (char *) "self",(char *) "menu",(char *) "title", NULL
35779 };
35780
35781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
35782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35783 if (SWIG_arg_fail(1)) SWIG_fail;
35784 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35785 if (SWIG_arg_fail(2)) SWIG_fail;
35786 {
35787 arg3 = wxString_in_helper(obj2);
35788 if (arg3 == NULL) SWIG_fail;
35789 temp3 = true;
35790 }
35791 {
35792 PyThreadState* __tstate = wxPyBeginAllowThreads();
35793 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
35794
35795 wxPyEndAllowThreads(__tstate);
35796 if (PyErr_Occurred()) SWIG_fail;
35797 }
35798 {
35799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35800 }
35801 {
35802 if (temp3)
35803 delete arg3;
35804 }
35805 return resultobj;
35806 fail:
35807 {
35808 if (temp3)
35809 delete arg3;
35810 }
35811 return NULL;
35812 }
35813
35814
35815 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35816 PyObject *resultobj = NULL;
35817 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35818 size_t arg2 ;
35819 wxMenu *arg3 = (wxMenu *) 0 ;
35820 wxString *arg4 = 0 ;
35821 bool result;
35822 bool temp4 = false ;
35823 PyObject * obj0 = 0 ;
35824 PyObject * obj1 = 0 ;
35825 PyObject * obj2 = 0 ;
35826 PyObject * obj3 = 0 ;
35827 char *kwnames[] = {
35828 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35829 };
35830
35831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35833 if (SWIG_arg_fail(1)) SWIG_fail;
35834 {
35835 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35836 if (SWIG_arg_fail(2)) SWIG_fail;
35837 }
35838 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35839 if (SWIG_arg_fail(3)) SWIG_fail;
35840 {
35841 arg4 = wxString_in_helper(obj3);
35842 if (arg4 == NULL) SWIG_fail;
35843 temp4 = true;
35844 }
35845 {
35846 PyThreadState* __tstate = wxPyBeginAllowThreads();
35847 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35848
35849 wxPyEndAllowThreads(__tstate);
35850 if (PyErr_Occurred()) SWIG_fail;
35851 }
35852 {
35853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35854 }
35855 {
35856 if (temp4)
35857 delete arg4;
35858 }
35859 return resultobj;
35860 fail:
35861 {
35862 if (temp4)
35863 delete arg4;
35864 }
35865 return NULL;
35866 }
35867
35868
35869 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35870 PyObject *resultobj = NULL;
35871 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35872 size_t result;
35873 PyObject * obj0 = 0 ;
35874 char *kwnames[] = {
35875 (char *) "self", NULL
35876 };
35877
35878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35880 if (SWIG_arg_fail(1)) SWIG_fail;
35881 {
35882 PyThreadState* __tstate = wxPyBeginAllowThreads();
35883 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35884
35885 wxPyEndAllowThreads(__tstate);
35886 if (PyErr_Occurred()) SWIG_fail;
35887 }
35888 {
35889 resultobj = SWIG_From_unsigned_SS_long(static_cast<unsigned long >(result));
35890 }
35891 return resultobj;
35892 fail:
35893 return NULL;
35894 }
35895
35896
35897 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35898 PyObject *resultobj = NULL;
35899 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35900 size_t arg2 ;
35901 wxMenu *result;
35902 PyObject * obj0 = 0 ;
35903 PyObject * obj1 = 0 ;
35904 char *kwnames[] = {
35905 (char *) "self",(char *) "pos", NULL
35906 };
35907
35908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35910 if (SWIG_arg_fail(1)) SWIG_fail;
35911 {
35912 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35913 if (SWIG_arg_fail(2)) SWIG_fail;
35914 }
35915 {
35916 PyThreadState* __tstate = wxPyBeginAllowThreads();
35917 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35918
35919 wxPyEndAllowThreads(__tstate);
35920 if (PyErr_Occurred()) SWIG_fail;
35921 }
35922 {
35923 resultobj = wxPyMake_wxObject(result, 0);
35924 }
35925 return resultobj;
35926 fail:
35927 return NULL;
35928 }
35929
35930
35931 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35932 PyObject *resultobj = NULL;
35933 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35934 size_t arg2 ;
35935 wxMenu *arg3 = (wxMenu *) 0 ;
35936 wxString *arg4 = 0 ;
35937 wxMenu *result;
35938 bool temp4 = false ;
35939 PyObject * obj0 = 0 ;
35940 PyObject * obj1 = 0 ;
35941 PyObject * obj2 = 0 ;
35942 PyObject * obj3 = 0 ;
35943 char *kwnames[] = {
35944 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35945 };
35946
35947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35949 if (SWIG_arg_fail(1)) SWIG_fail;
35950 {
35951 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
35952 if (SWIG_arg_fail(2)) SWIG_fail;
35953 }
35954 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35955 if (SWIG_arg_fail(3)) SWIG_fail;
35956 {
35957 arg4 = wxString_in_helper(obj3);
35958 if (arg4 == NULL) SWIG_fail;
35959 temp4 = true;
35960 }
35961 {
35962 PyThreadState* __tstate = wxPyBeginAllowThreads();
35963 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35964
35965 wxPyEndAllowThreads(__tstate);
35966 if (PyErr_Occurred()) SWIG_fail;
35967 }
35968 {
35969 resultobj = wxPyMake_wxObject(result, 0);
35970 }
35971 {
35972 if (temp4)
35973 delete arg4;
35974 }
35975 return resultobj;
35976 fail:
35977 {
35978 if (temp4)
35979 delete arg4;
35980 }
35981 return NULL;
35982 }
35983
35984
35985 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35986 PyObject *resultobj = NULL;
35987 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35988 size_t arg2 ;
35989 wxMenu *result;
35990 PyObject * obj0 = 0 ;
35991 PyObject * obj1 = 0 ;
35992 char *kwnames[] = {
35993 (char *) "self",(char *) "pos", NULL
35994 };
35995
35996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35998 if (SWIG_arg_fail(1)) SWIG_fail;
35999 {
36000 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36001 if (SWIG_arg_fail(2)) SWIG_fail;
36002 }
36003 {
36004 PyThreadState* __tstate = wxPyBeginAllowThreads();
36005 result = (wxMenu *)(arg1)->Remove(arg2);
36006
36007 wxPyEndAllowThreads(__tstate);
36008 if (PyErr_Occurred()) SWIG_fail;
36009 }
36010 {
36011 resultobj = wxPyMake_wxObject(result, 0);
36012 }
36013 return resultobj;
36014 fail:
36015 return NULL;
36016 }
36017
36018
36019 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
36020 PyObject *resultobj = NULL;
36021 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36022 size_t arg2 ;
36023 bool arg3 ;
36024 PyObject * obj0 = 0 ;
36025 PyObject * obj1 = 0 ;
36026 PyObject * obj2 = 0 ;
36027 char *kwnames[] = {
36028 (char *) "self",(char *) "pos",(char *) "enable", NULL
36029 };
36030
36031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
36032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36033 if (SWIG_arg_fail(1)) SWIG_fail;
36034 {
36035 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36036 if (SWIG_arg_fail(2)) SWIG_fail;
36037 }
36038 {
36039 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36040 if (SWIG_arg_fail(3)) SWIG_fail;
36041 }
36042 {
36043 PyThreadState* __tstate = wxPyBeginAllowThreads();
36044 (arg1)->EnableTop(arg2,arg3);
36045
36046 wxPyEndAllowThreads(__tstate);
36047 if (PyErr_Occurred()) SWIG_fail;
36048 }
36049 Py_INCREF(Py_None); resultobj = Py_None;
36050 return resultobj;
36051 fail:
36052 return NULL;
36053 }
36054
36055
36056 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
36057 PyObject *resultobj = NULL;
36058 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36059 size_t arg2 ;
36060 bool result;
36061 PyObject * obj0 = 0 ;
36062 PyObject * obj1 = 0 ;
36063 char *kwnames[] = {
36064 (char *) "self",(char *) "pos", NULL
36065 };
36066
36067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
36068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36069 if (SWIG_arg_fail(1)) SWIG_fail;
36070 {
36071 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36072 if (SWIG_arg_fail(2)) SWIG_fail;
36073 }
36074 {
36075 PyThreadState* __tstate = wxPyBeginAllowThreads();
36076 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
36077
36078 wxPyEndAllowThreads(__tstate);
36079 if (PyErr_Occurred()) SWIG_fail;
36080 }
36081 {
36082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36083 }
36084 return resultobj;
36085 fail:
36086 return NULL;
36087 }
36088
36089
36090 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
36091 PyObject *resultobj = NULL;
36092 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36093 size_t arg2 ;
36094 wxString *arg3 = 0 ;
36095 bool temp3 = false ;
36096 PyObject * obj0 = 0 ;
36097 PyObject * obj1 = 0 ;
36098 PyObject * obj2 = 0 ;
36099 char *kwnames[] = {
36100 (char *) "self",(char *) "pos",(char *) "label", NULL
36101 };
36102
36103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
36104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36105 if (SWIG_arg_fail(1)) SWIG_fail;
36106 {
36107 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36108 if (SWIG_arg_fail(2)) SWIG_fail;
36109 }
36110 {
36111 arg3 = wxString_in_helper(obj2);
36112 if (arg3 == NULL) SWIG_fail;
36113 temp3 = true;
36114 }
36115 {
36116 PyThreadState* __tstate = wxPyBeginAllowThreads();
36117 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
36118
36119 wxPyEndAllowThreads(__tstate);
36120 if (PyErr_Occurred()) SWIG_fail;
36121 }
36122 Py_INCREF(Py_None); resultobj = Py_None;
36123 {
36124 if (temp3)
36125 delete arg3;
36126 }
36127 return resultobj;
36128 fail:
36129 {
36130 if (temp3)
36131 delete arg3;
36132 }
36133 return NULL;
36134 }
36135
36136
36137 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
36138 PyObject *resultobj = NULL;
36139 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36140 size_t arg2 ;
36141 wxString result;
36142 PyObject * obj0 = 0 ;
36143 PyObject * obj1 = 0 ;
36144 char *kwnames[] = {
36145 (char *) "self",(char *) "pos", NULL
36146 };
36147
36148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
36149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36150 if (SWIG_arg_fail(1)) SWIG_fail;
36151 {
36152 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
36153 if (SWIG_arg_fail(2)) SWIG_fail;
36154 }
36155 {
36156 PyThreadState* __tstate = wxPyBeginAllowThreads();
36157 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
36158
36159 wxPyEndAllowThreads(__tstate);
36160 if (PyErr_Occurred()) SWIG_fail;
36161 }
36162 {
36163 #if wxUSE_UNICODE
36164 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36165 #else
36166 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36167 #endif
36168 }
36169 return resultobj;
36170 fail:
36171 return NULL;
36172 }
36173
36174
36175 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36176 PyObject *resultobj = NULL;
36177 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36178 wxString *arg2 = 0 ;
36179 wxString *arg3 = 0 ;
36180 int result;
36181 bool temp2 = false ;
36182 bool temp3 = false ;
36183 PyObject * obj0 = 0 ;
36184 PyObject * obj1 = 0 ;
36185 PyObject * obj2 = 0 ;
36186 char *kwnames[] = {
36187 (char *) "self",(char *) "menu",(char *) "item", NULL
36188 };
36189
36190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
36191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36192 if (SWIG_arg_fail(1)) SWIG_fail;
36193 {
36194 arg2 = wxString_in_helper(obj1);
36195 if (arg2 == NULL) SWIG_fail;
36196 temp2 = true;
36197 }
36198 {
36199 arg3 = wxString_in_helper(obj2);
36200 if (arg3 == NULL) SWIG_fail;
36201 temp3 = true;
36202 }
36203 {
36204 PyThreadState* __tstate = wxPyBeginAllowThreads();
36205 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
36206
36207 wxPyEndAllowThreads(__tstate);
36208 if (PyErr_Occurred()) SWIG_fail;
36209 }
36210 {
36211 resultobj = SWIG_From_int(static_cast<int >(result));
36212 }
36213 {
36214 if (temp2)
36215 delete arg2;
36216 }
36217 {
36218 if (temp3)
36219 delete arg3;
36220 }
36221 return resultobj;
36222 fail:
36223 {
36224 if (temp2)
36225 delete arg2;
36226 }
36227 {
36228 if (temp3)
36229 delete arg3;
36230 }
36231 return NULL;
36232 }
36233
36234
36235 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
36236 PyObject *resultobj = NULL;
36237 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36238 int arg2 ;
36239 wxMenuItem *result;
36240 PyObject * obj0 = 0 ;
36241 PyObject * obj1 = 0 ;
36242 char *kwnames[] = {
36243 (char *) "self",(char *) "id", NULL
36244 };
36245
36246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
36247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36248 if (SWIG_arg_fail(1)) SWIG_fail;
36249 {
36250 arg2 = static_cast<int >(SWIG_As_int(obj1));
36251 if (SWIG_arg_fail(2)) SWIG_fail;
36252 }
36253 {
36254 PyThreadState* __tstate = wxPyBeginAllowThreads();
36255 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
36256
36257 wxPyEndAllowThreads(__tstate);
36258 if (PyErr_Occurred()) SWIG_fail;
36259 }
36260 {
36261 resultobj = wxPyMake_wxObject(result, (bool)0);
36262 }
36263 return resultobj;
36264 fail:
36265 return NULL;
36266 }
36267
36268
36269 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36270 PyObject *resultobj = NULL;
36271 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36272 wxString *arg2 = 0 ;
36273 int result;
36274 bool temp2 = false ;
36275 PyObject * obj0 = 0 ;
36276 PyObject * obj1 = 0 ;
36277 char *kwnames[] = {
36278 (char *) "self",(char *) "title", NULL
36279 };
36280
36281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
36282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36283 if (SWIG_arg_fail(1)) SWIG_fail;
36284 {
36285 arg2 = wxString_in_helper(obj1);
36286 if (arg2 == NULL) SWIG_fail;
36287 temp2 = true;
36288 }
36289 {
36290 PyThreadState* __tstate = wxPyBeginAllowThreads();
36291 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
36292
36293 wxPyEndAllowThreads(__tstate);
36294 if (PyErr_Occurred()) SWIG_fail;
36295 }
36296 {
36297 resultobj = SWIG_From_int(static_cast<int >(result));
36298 }
36299 {
36300 if (temp2)
36301 delete arg2;
36302 }
36303 return resultobj;
36304 fail:
36305 {
36306 if (temp2)
36307 delete arg2;
36308 }
36309 return NULL;
36310 }
36311
36312
36313 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36314 PyObject *resultobj = NULL;
36315 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36316 int arg2 ;
36317 bool arg3 ;
36318 PyObject * obj0 = 0 ;
36319 PyObject * obj1 = 0 ;
36320 PyObject * obj2 = 0 ;
36321 char *kwnames[] = {
36322 (char *) "self",(char *) "id",(char *) "enable", NULL
36323 };
36324
36325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
36326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36327 if (SWIG_arg_fail(1)) SWIG_fail;
36328 {
36329 arg2 = static_cast<int >(SWIG_As_int(obj1));
36330 if (SWIG_arg_fail(2)) SWIG_fail;
36331 }
36332 {
36333 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36334 if (SWIG_arg_fail(3)) SWIG_fail;
36335 }
36336 {
36337 PyThreadState* __tstate = wxPyBeginAllowThreads();
36338 (arg1)->Enable(arg2,arg3);
36339
36340 wxPyEndAllowThreads(__tstate);
36341 if (PyErr_Occurred()) SWIG_fail;
36342 }
36343 Py_INCREF(Py_None); resultobj = Py_None;
36344 return resultobj;
36345 fail:
36346 return NULL;
36347 }
36348
36349
36350 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36351 PyObject *resultobj = NULL;
36352 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36353 int arg2 ;
36354 bool arg3 ;
36355 PyObject * obj0 = 0 ;
36356 PyObject * obj1 = 0 ;
36357 PyObject * obj2 = 0 ;
36358 char *kwnames[] = {
36359 (char *) "self",(char *) "id",(char *) "check", NULL
36360 };
36361
36362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
36363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36364 if (SWIG_arg_fail(1)) SWIG_fail;
36365 {
36366 arg2 = static_cast<int >(SWIG_As_int(obj1));
36367 if (SWIG_arg_fail(2)) SWIG_fail;
36368 }
36369 {
36370 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
36371 if (SWIG_arg_fail(3)) SWIG_fail;
36372 }
36373 {
36374 PyThreadState* __tstate = wxPyBeginAllowThreads();
36375 (arg1)->Check(arg2,arg3);
36376
36377 wxPyEndAllowThreads(__tstate);
36378 if (PyErr_Occurred()) SWIG_fail;
36379 }
36380 Py_INCREF(Py_None); resultobj = Py_None;
36381 return resultobj;
36382 fail:
36383 return NULL;
36384 }
36385
36386
36387 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36388 PyObject *resultobj = NULL;
36389 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36390 int arg2 ;
36391 bool result;
36392 PyObject * obj0 = 0 ;
36393 PyObject * obj1 = 0 ;
36394 char *kwnames[] = {
36395 (char *) "self",(char *) "id", NULL
36396 };
36397
36398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
36399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36400 if (SWIG_arg_fail(1)) SWIG_fail;
36401 {
36402 arg2 = static_cast<int >(SWIG_As_int(obj1));
36403 if (SWIG_arg_fail(2)) SWIG_fail;
36404 }
36405 {
36406 PyThreadState* __tstate = wxPyBeginAllowThreads();
36407 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
36408
36409 wxPyEndAllowThreads(__tstate);
36410 if (PyErr_Occurred()) SWIG_fail;
36411 }
36412 {
36413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36414 }
36415 return resultobj;
36416 fail:
36417 return NULL;
36418 }
36419
36420
36421 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36422 PyObject *resultobj = NULL;
36423 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36424 int arg2 ;
36425 bool result;
36426 PyObject * obj0 = 0 ;
36427 PyObject * obj1 = 0 ;
36428 char *kwnames[] = {
36429 (char *) "self",(char *) "id", NULL
36430 };
36431
36432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
36433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36434 if (SWIG_arg_fail(1)) SWIG_fail;
36435 {
36436 arg2 = static_cast<int >(SWIG_As_int(obj1));
36437 if (SWIG_arg_fail(2)) SWIG_fail;
36438 }
36439 {
36440 PyThreadState* __tstate = wxPyBeginAllowThreads();
36441 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
36442
36443 wxPyEndAllowThreads(__tstate);
36444 if (PyErr_Occurred()) SWIG_fail;
36445 }
36446 {
36447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36448 }
36449 return resultobj;
36450 fail:
36451 return NULL;
36452 }
36453
36454
36455 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36456 PyObject *resultobj = NULL;
36457 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36458 int arg2 ;
36459 wxString *arg3 = 0 ;
36460 bool temp3 = false ;
36461 PyObject * obj0 = 0 ;
36462 PyObject * obj1 = 0 ;
36463 PyObject * obj2 = 0 ;
36464 char *kwnames[] = {
36465 (char *) "self",(char *) "id",(char *) "label", NULL
36466 };
36467
36468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
36469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36470 if (SWIG_arg_fail(1)) SWIG_fail;
36471 {
36472 arg2 = static_cast<int >(SWIG_As_int(obj1));
36473 if (SWIG_arg_fail(2)) SWIG_fail;
36474 }
36475 {
36476 arg3 = wxString_in_helper(obj2);
36477 if (arg3 == NULL) SWIG_fail;
36478 temp3 = true;
36479 }
36480 {
36481 PyThreadState* __tstate = wxPyBeginAllowThreads();
36482 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
36483
36484 wxPyEndAllowThreads(__tstate);
36485 if (PyErr_Occurred()) SWIG_fail;
36486 }
36487 Py_INCREF(Py_None); resultobj = Py_None;
36488 {
36489 if (temp3)
36490 delete arg3;
36491 }
36492 return resultobj;
36493 fail:
36494 {
36495 if (temp3)
36496 delete arg3;
36497 }
36498 return NULL;
36499 }
36500
36501
36502 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36503 PyObject *resultobj = NULL;
36504 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36505 int arg2 ;
36506 wxString result;
36507 PyObject * obj0 = 0 ;
36508 PyObject * obj1 = 0 ;
36509 char *kwnames[] = {
36510 (char *) "self",(char *) "id", NULL
36511 };
36512
36513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
36514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36515 if (SWIG_arg_fail(1)) SWIG_fail;
36516 {
36517 arg2 = static_cast<int >(SWIG_As_int(obj1));
36518 if (SWIG_arg_fail(2)) SWIG_fail;
36519 }
36520 {
36521 PyThreadState* __tstate = wxPyBeginAllowThreads();
36522 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
36523
36524 wxPyEndAllowThreads(__tstate);
36525 if (PyErr_Occurred()) SWIG_fail;
36526 }
36527 {
36528 #if wxUSE_UNICODE
36529 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36530 #else
36531 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36532 #endif
36533 }
36534 return resultobj;
36535 fail:
36536 return NULL;
36537 }
36538
36539
36540 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36541 PyObject *resultobj = NULL;
36542 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36543 int arg2 ;
36544 wxString *arg3 = 0 ;
36545 bool temp3 = false ;
36546 PyObject * obj0 = 0 ;
36547 PyObject * obj1 = 0 ;
36548 PyObject * obj2 = 0 ;
36549 char *kwnames[] = {
36550 (char *) "self",(char *) "id",(char *) "helpString", NULL
36551 };
36552
36553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36555 if (SWIG_arg_fail(1)) SWIG_fail;
36556 {
36557 arg2 = static_cast<int >(SWIG_As_int(obj1));
36558 if (SWIG_arg_fail(2)) SWIG_fail;
36559 }
36560 {
36561 arg3 = wxString_in_helper(obj2);
36562 if (arg3 == NULL) SWIG_fail;
36563 temp3 = true;
36564 }
36565 {
36566 PyThreadState* __tstate = wxPyBeginAllowThreads();
36567 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
36568
36569 wxPyEndAllowThreads(__tstate);
36570 if (PyErr_Occurred()) SWIG_fail;
36571 }
36572 Py_INCREF(Py_None); resultobj = Py_None;
36573 {
36574 if (temp3)
36575 delete arg3;
36576 }
36577 return resultobj;
36578 fail:
36579 {
36580 if (temp3)
36581 delete arg3;
36582 }
36583 return NULL;
36584 }
36585
36586
36587 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36588 PyObject *resultobj = NULL;
36589 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36590 int arg2 ;
36591 wxString result;
36592 PyObject * obj0 = 0 ;
36593 PyObject * obj1 = 0 ;
36594 char *kwnames[] = {
36595 (char *) "self",(char *) "id", NULL
36596 };
36597
36598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
36599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36600 if (SWIG_arg_fail(1)) SWIG_fail;
36601 {
36602 arg2 = static_cast<int >(SWIG_As_int(obj1));
36603 if (SWIG_arg_fail(2)) SWIG_fail;
36604 }
36605 {
36606 PyThreadState* __tstate = wxPyBeginAllowThreads();
36607 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
36608
36609 wxPyEndAllowThreads(__tstate);
36610 if (PyErr_Occurred()) SWIG_fail;
36611 }
36612 {
36613 #if wxUSE_UNICODE
36614 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36615 #else
36616 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36617 #endif
36618 }
36619 return resultobj;
36620 fail:
36621 return NULL;
36622 }
36623
36624
36625 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
36626 PyObject *resultobj = NULL;
36627 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36628 wxFrame *result;
36629 PyObject * obj0 = 0 ;
36630 char *kwnames[] = {
36631 (char *) "self", NULL
36632 };
36633
36634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
36635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36636 if (SWIG_arg_fail(1)) SWIG_fail;
36637 {
36638 PyThreadState* __tstate = wxPyBeginAllowThreads();
36639 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
36640
36641 wxPyEndAllowThreads(__tstate);
36642 if (PyErr_Occurred()) SWIG_fail;
36643 }
36644 {
36645 resultobj = wxPyMake_wxObject(result, (bool)0);
36646 }
36647 return resultobj;
36648 fail:
36649 return NULL;
36650 }
36651
36652
36653 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
36654 PyObject *resultobj = NULL;
36655 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36656 bool result;
36657 PyObject * obj0 = 0 ;
36658 char *kwnames[] = {
36659 (char *) "self", NULL
36660 };
36661
36662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
36663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36664 if (SWIG_arg_fail(1)) SWIG_fail;
36665 {
36666 PyThreadState* __tstate = wxPyBeginAllowThreads();
36667 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
36668
36669 wxPyEndAllowThreads(__tstate);
36670 if (PyErr_Occurred()) SWIG_fail;
36671 }
36672 {
36673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36674 }
36675 return resultobj;
36676 fail:
36677 return NULL;
36678 }
36679
36680
36681 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
36682 PyObject *resultobj = NULL;
36683 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36684 wxFrame *arg2 = (wxFrame *) 0 ;
36685 PyObject * obj0 = 0 ;
36686 PyObject * obj1 = 0 ;
36687 char *kwnames[] = {
36688 (char *) "self",(char *) "frame", NULL
36689 };
36690
36691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
36692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36693 if (SWIG_arg_fail(1)) SWIG_fail;
36694 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
36695 if (SWIG_arg_fail(2)) SWIG_fail;
36696 {
36697 PyThreadState* __tstate = wxPyBeginAllowThreads();
36698 (arg1)->Attach(arg2);
36699
36700 wxPyEndAllowThreads(__tstate);
36701 if (PyErr_Occurred()) SWIG_fail;
36702 }
36703 Py_INCREF(Py_None); resultobj = Py_None;
36704 return resultobj;
36705 fail:
36706 return NULL;
36707 }
36708
36709
36710 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
36711 PyObject *resultobj = NULL;
36712 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36713 PyObject * obj0 = 0 ;
36714 char *kwnames[] = {
36715 (char *) "self", NULL
36716 };
36717
36718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
36719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36720 if (SWIG_arg_fail(1)) SWIG_fail;
36721 {
36722 PyThreadState* __tstate = wxPyBeginAllowThreads();
36723 (arg1)->Detach();
36724
36725 wxPyEndAllowThreads(__tstate);
36726 if (PyErr_Occurred()) SWIG_fail;
36727 }
36728 Py_INCREF(Py_None); resultobj = Py_None;
36729 return resultobj;
36730 fail:
36731 return NULL;
36732 }
36733
36734
36735 static PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36736 PyObject *resultobj = NULL;
36737 bool arg1 ;
36738 PyObject * obj0 = 0 ;
36739 char *kwnames[] = {
36740 (char *) "enable", NULL
36741 };
36742
36743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) goto fail;
36744 {
36745 arg1 = static_cast<bool >(SWIG_As_bool(obj0));
36746 if (SWIG_arg_fail(1)) SWIG_fail;
36747 }
36748 {
36749 PyThreadState* __tstate = wxPyBeginAllowThreads();
36750 wxMenuBar_SetAutoWindowMenu(arg1);
36751
36752 wxPyEndAllowThreads(__tstate);
36753 if (PyErr_Occurred()) SWIG_fail;
36754 }
36755 Py_INCREF(Py_None); resultobj = Py_None;
36756 return resultobj;
36757 fail:
36758 return NULL;
36759 }
36760
36761
36762 static PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36763 PyObject *resultobj = NULL;
36764 bool result;
36765 char *kwnames[] = {
36766 NULL
36767 };
36768
36769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuBar_GetAutoWindowMenu",kwnames)) goto fail;
36770 {
36771 PyThreadState* __tstate = wxPyBeginAllowThreads();
36772 result = (bool)wxMenuBar_GetAutoWindowMenu();
36773
36774 wxPyEndAllowThreads(__tstate);
36775 if (PyErr_Occurred()) SWIG_fail;
36776 }
36777 {
36778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36779 }
36780 return resultobj;
36781 fail:
36782 return NULL;
36783 }
36784
36785
36786 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
36787 PyObject *obj;
36788 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36789 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
36790 Py_INCREF(obj);
36791 return Py_BuildValue((char *)"");
36792 }
36793 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36794 PyObject *resultobj = NULL;
36795 wxMenu *arg1 = (wxMenu *) NULL ;
36796 int arg2 = (int) wxID_ANY ;
36797 wxString const &arg3_defvalue = wxPyEmptyString ;
36798 wxString *arg3 = (wxString *) &arg3_defvalue ;
36799 wxString const &arg4_defvalue = wxPyEmptyString ;
36800 wxString *arg4 = (wxString *) &arg4_defvalue ;
36801 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
36802 wxMenu *arg6 = (wxMenu *) NULL ;
36803 wxMenuItem *result;
36804 bool temp3 = false ;
36805 bool temp4 = false ;
36806 PyObject * obj0 = 0 ;
36807 PyObject * obj1 = 0 ;
36808 PyObject * obj2 = 0 ;
36809 PyObject * obj3 = 0 ;
36810 PyObject * obj4 = 0 ;
36811 PyObject * obj5 = 0 ;
36812 char *kwnames[] = {
36813 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
36814 };
36815
36816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
36817 if (obj0) {
36818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36819 if (SWIG_arg_fail(1)) SWIG_fail;
36820 }
36821 if (obj1) {
36822 {
36823 arg2 = static_cast<int >(SWIG_As_int(obj1));
36824 if (SWIG_arg_fail(2)) SWIG_fail;
36825 }
36826 }
36827 if (obj2) {
36828 {
36829 arg3 = wxString_in_helper(obj2);
36830 if (arg3 == NULL) SWIG_fail;
36831 temp3 = true;
36832 }
36833 }
36834 if (obj3) {
36835 {
36836 arg4 = wxString_in_helper(obj3);
36837 if (arg4 == NULL) SWIG_fail;
36838 temp4 = true;
36839 }
36840 }
36841 if (obj4) {
36842 {
36843 arg5 = static_cast<wxItemKind >(SWIG_As_int(obj4));
36844 if (SWIG_arg_fail(5)) SWIG_fail;
36845 }
36846 }
36847 if (obj5) {
36848 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36849 if (SWIG_arg_fail(6)) SWIG_fail;
36850 }
36851 {
36852 PyThreadState* __tstate = wxPyBeginAllowThreads();
36853 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
36854
36855 wxPyEndAllowThreads(__tstate);
36856 if (PyErr_Occurred()) SWIG_fail;
36857 }
36858 {
36859 resultobj = wxPyMake_wxObject(result, (bool)1);
36860 }
36861 {
36862 if (temp3)
36863 delete arg3;
36864 }
36865 {
36866 if (temp4)
36867 delete arg4;
36868 }
36869 return resultobj;
36870 fail:
36871 {
36872 if (temp3)
36873 delete arg3;
36874 }
36875 {
36876 if (temp4)
36877 delete arg4;
36878 }
36879 return NULL;
36880 }
36881
36882
36883 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36884 PyObject *resultobj = NULL;
36885 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36886 wxMenu *result;
36887 PyObject * obj0 = 0 ;
36888 char *kwnames[] = {
36889 (char *) "self", NULL
36890 };
36891
36892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36894 if (SWIG_arg_fail(1)) SWIG_fail;
36895 {
36896 PyThreadState* __tstate = wxPyBeginAllowThreads();
36897 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36898
36899 wxPyEndAllowThreads(__tstate);
36900 if (PyErr_Occurred()) SWIG_fail;
36901 }
36902 {
36903 resultobj = wxPyMake_wxObject(result, 0);
36904 }
36905 return resultobj;
36906 fail:
36907 return NULL;
36908 }
36909
36910
36911 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36912 PyObject *resultobj = NULL;
36913 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36914 wxMenu *arg2 = (wxMenu *) 0 ;
36915 PyObject * obj0 = 0 ;
36916 PyObject * obj1 = 0 ;
36917 char *kwnames[] = {
36918 (char *) "self",(char *) "menu", NULL
36919 };
36920
36921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36923 if (SWIG_arg_fail(1)) SWIG_fail;
36924 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36925 if (SWIG_arg_fail(2)) SWIG_fail;
36926 {
36927 PyThreadState* __tstate = wxPyBeginAllowThreads();
36928 (arg1)->SetMenu(arg2);
36929
36930 wxPyEndAllowThreads(__tstate);
36931 if (PyErr_Occurred()) SWIG_fail;
36932 }
36933 Py_INCREF(Py_None); resultobj = Py_None;
36934 return resultobj;
36935 fail:
36936 return NULL;
36937 }
36938
36939
36940 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36941 PyObject *resultobj = NULL;
36942 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36943 int arg2 ;
36944 PyObject * obj0 = 0 ;
36945 PyObject * obj1 = 0 ;
36946 char *kwnames[] = {
36947 (char *) "self",(char *) "id", NULL
36948 };
36949
36950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36952 if (SWIG_arg_fail(1)) SWIG_fail;
36953 {
36954 arg2 = static_cast<int >(SWIG_As_int(obj1));
36955 if (SWIG_arg_fail(2)) SWIG_fail;
36956 }
36957 {
36958 PyThreadState* __tstate = wxPyBeginAllowThreads();
36959 (arg1)->SetId(arg2);
36960
36961 wxPyEndAllowThreads(__tstate);
36962 if (PyErr_Occurred()) SWIG_fail;
36963 }
36964 Py_INCREF(Py_None); resultobj = Py_None;
36965 return resultobj;
36966 fail:
36967 return NULL;
36968 }
36969
36970
36971 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36972 PyObject *resultobj = NULL;
36973 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36974 int result;
36975 PyObject * obj0 = 0 ;
36976 char *kwnames[] = {
36977 (char *) "self", NULL
36978 };
36979
36980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36982 if (SWIG_arg_fail(1)) SWIG_fail;
36983 {
36984 PyThreadState* __tstate = wxPyBeginAllowThreads();
36985 result = (int)((wxMenuItem const *)arg1)->GetId();
36986
36987 wxPyEndAllowThreads(__tstate);
36988 if (PyErr_Occurred()) SWIG_fail;
36989 }
36990 {
36991 resultobj = SWIG_From_int(static_cast<int >(result));
36992 }
36993 return resultobj;
36994 fail:
36995 return NULL;
36996 }
36997
36998
36999 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
37000 PyObject *resultobj = NULL;
37001 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37002 bool result;
37003 PyObject * obj0 = 0 ;
37004 char *kwnames[] = {
37005 (char *) "self", NULL
37006 };
37007
37008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
37009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37010 if (SWIG_arg_fail(1)) SWIG_fail;
37011 {
37012 PyThreadState* __tstate = wxPyBeginAllowThreads();
37013 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
37014
37015 wxPyEndAllowThreads(__tstate);
37016 if (PyErr_Occurred()) SWIG_fail;
37017 }
37018 {
37019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37020 }
37021 return resultobj;
37022 fail:
37023 return NULL;
37024 }
37025
37026
37027 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
37028 PyObject *resultobj = NULL;
37029 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37030 wxString *arg2 = 0 ;
37031 bool temp2 = false ;
37032 PyObject * obj0 = 0 ;
37033 PyObject * obj1 = 0 ;
37034 char *kwnames[] = {
37035 (char *) "self",(char *) "str", NULL
37036 };
37037
37038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
37039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37040 if (SWIG_arg_fail(1)) SWIG_fail;
37041 {
37042 arg2 = wxString_in_helper(obj1);
37043 if (arg2 == NULL) SWIG_fail;
37044 temp2 = true;
37045 }
37046 {
37047 PyThreadState* __tstate = wxPyBeginAllowThreads();
37048 (arg1)->SetText((wxString const &)*arg2);
37049
37050 wxPyEndAllowThreads(__tstate);
37051 if (PyErr_Occurred()) SWIG_fail;
37052 }
37053 Py_INCREF(Py_None); resultobj = Py_None;
37054 {
37055 if (temp2)
37056 delete arg2;
37057 }
37058 return resultobj;
37059 fail:
37060 {
37061 if (temp2)
37062 delete arg2;
37063 }
37064 return NULL;
37065 }
37066
37067
37068 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37069 PyObject *resultobj = NULL;
37070 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37071 wxString result;
37072 PyObject * obj0 = 0 ;
37073 char *kwnames[] = {
37074 (char *) "self", NULL
37075 };
37076
37077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
37078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37079 if (SWIG_arg_fail(1)) SWIG_fail;
37080 {
37081 PyThreadState* __tstate = wxPyBeginAllowThreads();
37082 result = ((wxMenuItem const *)arg1)->GetLabel();
37083
37084 wxPyEndAllowThreads(__tstate);
37085 if (PyErr_Occurred()) SWIG_fail;
37086 }
37087 {
37088 #if wxUSE_UNICODE
37089 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37090 #else
37091 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37092 #endif
37093 }
37094 return resultobj;
37095 fail:
37096 return NULL;
37097 }
37098
37099
37100 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
37101 PyObject *resultobj = NULL;
37102 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37103 wxString *result;
37104 PyObject * obj0 = 0 ;
37105 char *kwnames[] = {
37106 (char *) "self", NULL
37107 };
37108
37109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
37110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37111 if (SWIG_arg_fail(1)) SWIG_fail;
37112 {
37113 PyThreadState* __tstate = wxPyBeginAllowThreads();
37114 {
37115 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
37116 result = (wxString *) &_result_ref;
37117 }
37118
37119 wxPyEndAllowThreads(__tstate);
37120 if (PyErr_Occurred()) SWIG_fail;
37121 }
37122 {
37123 #if wxUSE_UNICODE
37124 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37125 #else
37126 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37127 #endif
37128 }
37129 return resultobj;
37130 fail:
37131 return NULL;
37132 }
37133
37134
37135 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
37136 PyObject *resultobj = NULL;
37137 wxString *arg1 = 0 ;
37138 wxString result;
37139 bool temp1 = false ;
37140 PyObject * obj0 = 0 ;
37141 char *kwnames[] = {
37142 (char *) "text", NULL
37143 };
37144
37145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
37146 {
37147 arg1 = wxString_in_helper(obj0);
37148 if (arg1 == NULL) SWIG_fail;
37149 temp1 = true;
37150 }
37151 {
37152 PyThreadState* __tstate = wxPyBeginAllowThreads();
37153 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
37154
37155 wxPyEndAllowThreads(__tstate);
37156 if (PyErr_Occurred()) SWIG_fail;
37157 }
37158 {
37159 #if wxUSE_UNICODE
37160 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37161 #else
37162 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37163 #endif
37164 }
37165 {
37166 if (temp1)
37167 delete arg1;
37168 }
37169 return resultobj;
37170 fail:
37171 {
37172 if (temp1)
37173 delete arg1;
37174 }
37175 return NULL;
37176 }
37177
37178
37179 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
37180 PyObject *resultobj = NULL;
37181 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37182 wxItemKind result;
37183 PyObject * obj0 = 0 ;
37184 char *kwnames[] = {
37185 (char *) "self", NULL
37186 };
37187
37188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
37189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37190 if (SWIG_arg_fail(1)) SWIG_fail;
37191 {
37192 PyThreadState* __tstate = wxPyBeginAllowThreads();
37193 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
37194
37195 wxPyEndAllowThreads(__tstate);
37196 if (PyErr_Occurred()) SWIG_fail;
37197 }
37198 resultobj = SWIG_From_int((result));
37199 return resultobj;
37200 fail:
37201 return NULL;
37202 }
37203
37204
37205 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
37206 PyObject *resultobj = NULL;
37207 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37208 wxItemKind arg2 ;
37209 PyObject * obj0 = 0 ;
37210 PyObject * obj1 = 0 ;
37211 char *kwnames[] = {
37212 (char *) "self",(char *) "kind", NULL
37213 };
37214
37215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
37216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37217 if (SWIG_arg_fail(1)) SWIG_fail;
37218 {
37219 arg2 = static_cast<wxItemKind >(SWIG_As_int(obj1));
37220 if (SWIG_arg_fail(2)) SWIG_fail;
37221 }
37222 {
37223 PyThreadState* __tstate = wxPyBeginAllowThreads();
37224 (arg1)->SetKind(arg2);
37225
37226 wxPyEndAllowThreads(__tstate);
37227 if (PyErr_Occurred()) SWIG_fail;
37228 }
37229 Py_INCREF(Py_None); resultobj = Py_None;
37230 return resultobj;
37231 fail:
37232 return NULL;
37233 }
37234
37235
37236 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37237 PyObject *resultobj = NULL;
37238 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37239 bool arg2 ;
37240 PyObject * obj0 = 0 ;
37241 PyObject * obj1 = 0 ;
37242 char *kwnames[] = {
37243 (char *) "self",(char *) "checkable", NULL
37244 };
37245
37246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
37247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37248 if (SWIG_arg_fail(1)) SWIG_fail;
37249 {
37250 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37251 if (SWIG_arg_fail(2)) SWIG_fail;
37252 }
37253 {
37254 PyThreadState* __tstate = wxPyBeginAllowThreads();
37255 (arg1)->SetCheckable(arg2);
37256
37257 wxPyEndAllowThreads(__tstate);
37258 if (PyErr_Occurred()) SWIG_fail;
37259 }
37260 Py_INCREF(Py_None); resultobj = Py_None;
37261 return resultobj;
37262 fail:
37263 return NULL;
37264 }
37265
37266
37267 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
37268 PyObject *resultobj = NULL;
37269 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37270 bool result;
37271 PyObject * obj0 = 0 ;
37272 char *kwnames[] = {
37273 (char *) "self", NULL
37274 };
37275
37276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
37277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37278 if (SWIG_arg_fail(1)) SWIG_fail;
37279 {
37280 PyThreadState* __tstate = wxPyBeginAllowThreads();
37281 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
37282
37283 wxPyEndAllowThreads(__tstate);
37284 if (PyErr_Occurred()) SWIG_fail;
37285 }
37286 {
37287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37288 }
37289 return resultobj;
37290 fail:
37291 return NULL;
37292 }
37293
37294
37295 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37296 PyObject *resultobj = NULL;
37297 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37298 bool result;
37299 PyObject * obj0 = 0 ;
37300 char *kwnames[] = {
37301 (char *) "self", NULL
37302 };
37303
37304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
37305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37306 if (SWIG_arg_fail(1)) SWIG_fail;
37307 {
37308 PyThreadState* __tstate = wxPyBeginAllowThreads();
37309 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
37310
37311 wxPyEndAllowThreads(__tstate);
37312 if (PyErr_Occurred()) SWIG_fail;
37313 }
37314 {
37315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37316 }
37317 return resultobj;
37318 fail:
37319 return NULL;
37320 }
37321
37322
37323 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37324 PyObject *resultobj = NULL;
37325 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37326 wxMenu *arg2 = (wxMenu *) 0 ;
37327 PyObject * obj0 = 0 ;
37328 PyObject * obj1 = 0 ;
37329 char *kwnames[] = {
37330 (char *) "self",(char *) "menu", NULL
37331 };
37332
37333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
37334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37335 if (SWIG_arg_fail(1)) SWIG_fail;
37336 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
37337 if (SWIG_arg_fail(2)) SWIG_fail;
37338 {
37339 PyThreadState* __tstate = wxPyBeginAllowThreads();
37340 (arg1)->SetSubMenu(arg2);
37341
37342 wxPyEndAllowThreads(__tstate);
37343 if (PyErr_Occurred()) SWIG_fail;
37344 }
37345 Py_INCREF(Py_None); resultobj = Py_None;
37346 return resultobj;
37347 fail:
37348 return NULL;
37349 }
37350
37351
37352 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37353 PyObject *resultobj = NULL;
37354 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37355 wxMenu *result;
37356 PyObject * obj0 = 0 ;
37357 char *kwnames[] = {
37358 (char *) "self", NULL
37359 };
37360
37361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
37362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37363 if (SWIG_arg_fail(1)) SWIG_fail;
37364 {
37365 PyThreadState* __tstate = wxPyBeginAllowThreads();
37366 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
37367
37368 wxPyEndAllowThreads(__tstate);
37369 if (PyErr_Occurred()) SWIG_fail;
37370 }
37371 {
37372 resultobj = wxPyMake_wxObject(result, 0);
37373 }
37374 return resultobj;
37375 fail:
37376 return NULL;
37377 }
37378
37379
37380 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
37381 PyObject *resultobj = NULL;
37382 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37383 bool arg2 = (bool) true ;
37384 PyObject * obj0 = 0 ;
37385 PyObject * obj1 = 0 ;
37386 char *kwnames[] = {
37387 (char *) "self",(char *) "enable", NULL
37388 };
37389
37390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
37391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37392 if (SWIG_arg_fail(1)) SWIG_fail;
37393 if (obj1) {
37394 {
37395 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37396 if (SWIG_arg_fail(2)) SWIG_fail;
37397 }
37398 }
37399 {
37400 PyThreadState* __tstate = wxPyBeginAllowThreads();
37401 (arg1)->Enable(arg2);
37402
37403 wxPyEndAllowThreads(__tstate);
37404 if (PyErr_Occurred()) SWIG_fail;
37405 }
37406 Py_INCREF(Py_None); resultobj = Py_None;
37407 return resultobj;
37408 fail:
37409 return NULL;
37410 }
37411
37412
37413 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
37414 PyObject *resultobj = NULL;
37415 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37416 bool result;
37417 PyObject * obj0 = 0 ;
37418 char *kwnames[] = {
37419 (char *) "self", NULL
37420 };
37421
37422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
37423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37424 if (SWIG_arg_fail(1)) SWIG_fail;
37425 {
37426 PyThreadState* __tstate = wxPyBeginAllowThreads();
37427 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
37428
37429 wxPyEndAllowThreads(__tstate);
37430 if (PyErr_Occurred()) SWIG_fail;
37431 }
37432 {
37433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37434 }
37435 return resultobj;
37436 fail:
37437 return NULL;
37438 }
37439
37440
37441 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
37442 PyObject *resultobj = NULL;
37443 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37444 bool arg2 = (bool) true ;
37445 PyObject * obj0 = 0 ;
37446 PyObject * obj1 = 0 ;
37447 char *kwnames[] = {
37448 (char *) "self",(char *) "check", NULL
37449 };
37450
37451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
37452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37453 if (SWIG_arg_fail(1)) SWIG_fail;
37454 if (obj1) {
37455 {
37456 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
37457 if (SWIG_arg_fail(2)) SWIG_fail;
37458 }
37459 }
37460 {
37461 PyThreadState* __tstate = wxPyBeginAllowThreads();
37462 (arg1)->Check(arg2);
37463
37464 wxPyEndAllowThreads(__tstate);
37465 if (PyErr_Occurred()) SWIG_fail;
37466 }
37467 Py_INCREF(Py_None); resultobj = Py_None;
37468 return resultobj;
37469 fail:
37470 return NULL;
37471 }
37472
37473
37474 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
37475 PyObject *resultobj = NULL;
37476 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37477 bool result;
37478 PyObject * obj0 = 0 ;
37479 char *kwnames[] = {
37480 (char *) "self", NULL
37481 };
37482
37483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
37484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37485 if (SWIG_arg_fail(1)) SWIG_fail;
37486 {
37487 PyThreadState* __tstate = wxPyBeginAllowThreads();
37488 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
37489
37490 wxPyEndAllowThreads(__tstate);
37491 if (PyErr_Occurred()) SWIG_fail;
37492 }
37493 {
37494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37495 }
37496 return resultobj;
37497 fail:
37498 return NULL;
37499 }
37500
37501
37502 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
37503 PyObject *resultobj = NULL;
37504 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37505 PyObject * obj0 = 0 ;
37506 char *kwnames[] = {
37507 (char *) "self", NULL
37508 };
37509
37510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
37511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37512 if (SWIG_arg_fail(1)) SWIG_fail;
37513 {
37514 PyThreadState* __tstate = wxPyBeginAllowThreads();
37515 (arg1)->Toggle();
37516
37517 wxPyEndAllowThreads(__tstate);
37518 if (PyErr_Occurred()) SWIG_fail;
37519 }
37520 Py_INCREF(Py_None); resultobj = Py_None;
37521 return resultobj;
37522 fail:
37523 return NULL;
37524 }
37525
37526
37527 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37528 PyObject *resultobj = NULL;
37529 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37530 wxString *arg2 = 0 ;
37531 bool temp2 = false ;
37532 PyObject * obj0 = 0 ;
37533 PyObject * obj1 = 0 ;
37534 char *kwnames[] = {
37535 (char *) "self",(char *) "str", NULL
37536 };
37537
37538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
37539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37540 if (SWIG_arg_fail(1)) SWIG_fail;
37541 {
37542 arg2 = wxString_in_helper(obj1);
37543 if (arg2 == NULL) SWIG_fail;
37544 temp2 = true;
37545 }
37546 {
37547 PyThreadState* __tstate = wxPyBeginAllowThreads();
37548 (arg1)->SetHelp((wxString const &)*arg2);
37549
37550 wxPyEndAllowThreads(__tstate);
37551 if (PyErr_Occurred()) SWIG_fail;
37552 }
37553 Py_INCREF(Py_None); resultobj = Py_None;
37554 {
37555 if (temp2)
37556 delete arg2;
37557 }
37558 return resultobj;
37559 fail:
37560 {
37561 if (temp2)
37562 delete arg2;
37563 }
37564 return NULL;
37565 }
37566
37567
37568 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37569 PyObject *resultobj = NULL;
37570 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37571 wxString *result;
37572 PyObject * obj0 = 0 ;
37573 char *kwnames[] = {
37574 (char *) "self", NULL
37575 };
37576
37577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
37578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37579 if (SWIG_arg_fail(1)) SWIG_fail;
37580 {
37581 PyThreadState* __tstate = wxPyBeginAllowThreads();
37582 {
37583 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
37584 result = (wxString *) &_result_ref;
37585 }
37586
37587 wxPyEndAllowThreads(__tstate);
37588 if (PyErr_Occurred()) SWIG_fail;
37589 }
37590 {
37591 #if wxUSE_UNICODE
37592 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37593 #else
37594 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37595 #endif
37596 }
37597 return resultobj;
37598 fail:
37599 return NULL;
37600 }
37601
37602
37603 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37604 PyObject *resultobj = NULL;
37605 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37606 wxAcceleratorEntry *result;
37607 PyObject * obj0 = 0 ;
37608 char *kwnames[] = {
37609 (char *) "self", NULL
37610 };
37611
37612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
37613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37614 if (SWIG_arg_fail(1)) SWIG_fail;
37615 {
37616 PyThreadState* __tstate = wxPyBeginAllowThreads();
37617 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
37618
37619 wxPyEndAllowThreads(__tstate);
37620 if (PyErr_Occurred()) SWIG_fail;
37621 }
37622 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
37623 return resultobj;
37624 fail:
37625 return NULL;
37626 }
37627
37628
37629 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37630 PyObject *resultobj = NULL;
37631 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37632 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
37633 PyObject * obj0 = 0 ;
37634 PyObject * obj1 = 0 ;
37635 char *kwnames[] = {
37636 (char *) "self",(char *) "accel", NULL
37637 };
37638
37639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
37640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37641 if (SWIG_arg_fail(1)) SWIG_fail;
37642 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
37643 if (SWIG_arg_fail(2)) SWIG_fail;
37644 {
37645 PyThreadState* __tstate = wxPyBeginAllowThreads();
37646 (arg1)->SetAccel(arg2);
37647
37648 wxPyEndAllowThreads(__tstate);
37649 if (PyErr_Occurred()) SWIG_fail;
37650 }
37651 Py_INCREF(Py_None); resultobj = Py_None;
37652 return resultobj;
37653 fail:
37654 return NULL;
37655 }
37656
37657
37658 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37659 PyObject *resultobj = NULL;
37660 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37661 wxBitmap *arg2 = 0 ;
37662 PyObject * obj0 = 0 ;
37663 PyObject * obj1 = 0 ;
37664 char *kwnames[] = {
37665 (char *) "self",(char *) "bitmap", NULL
37666 };
37667
37668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37670 if (SWIG_arg_fail(1)) SWIG_fail;
37671 {
37672 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37673 if (SWIG_arg_fail(2)) SWIG_fail;
37674 if (arg2 == NULL) {
37675 SWIG_null_ref("wxBitmap");
37676 }
37677 if (SWIG_arg_fail(2)) SWIG_fail;
37678 }
37679 {
37680 PyThreadState* __tstate = wxPyBeginAllowThreads();
37681 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37682
37683 wxPyEndAllowThreads(__tstate);
37684 if (PyErr_Occurred()) SWIG_fail;
37685 }
37686 Py_INCREF(Py_None); resultobj = Py_None;
37687 return resultobj;
37688 fail:
37689 return NULL;
37690 }
37691
37692
37693 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37694 PyObject *resultobj = NULL;
37695 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37696 wxBitmap *result;
37697 PyObject * obj0 = 0 ;
37698 char *kwnames[] = {
37699 (char *) "self", NULL
37700 };
37701
37702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37704 if (SWIG_arg_fail(1)) SWIG_fail;
37705 {
37706 PyThreadState* __tstate = wxPyBeginAllowThreads();
37707 {
37708 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37709 result = (wxBitmap *) &_result_ref;
37710 }
37711
37712 wxPyEndAllowThreads(__tstate);
37713 if (PyErr_Occurred()) SWIG_fail;
37714 }
37715 {
37716 wxBitmap* resultptr = new wxBitmap(*result);
37717 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37718 }
37719 return resultobj;
37720 fail:
37721 return NULL;
37722 }
37723
37724
37725 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37726 PyObject *resultobj = NULL;
37727 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37728 wxFont *arg2 = 0 ;
37729 PyObject * obj0 = 0 ;
37730 PyObject * obj1 = 0 ;
37731 char *kwnames[] = {
37732 (char *) "self",(char *) "font", NULL
37733 };
37734
37735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
37736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37737 if (SWIG_arg_fail(1)) SWIG_fail;
37738 {
37739 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
37740 if (SWIG_arg_fail(2)) SWIG_fail;
37741 if (arg2 == NULL) {
37742 SWIG_null_ref("wxFont");
37743 }
37744 if (SWIG_arg_fail(2)) SWIG_fail;
37745 }
37746 {
37747 PyThreadState* __tstate = wxPyBeginAllowThreads();
37748 (arg1)->SetFont((wxFont const &)*arg2);
37749
37750 wxPyEndAllowThreads(__tstate);
37751 if (PyErr_Occurred()) SWIG_fail;
37752 }
37753 Py_INCREF(Py_None); resultobj = Py_None;
37754 return resultobj;
37755 fail:
37756 return NULL;
37757 }
37758
37759
37760 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37761 PyObject *resultobj = NULL;
37762 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37763 wxFont result;
37764 PyObject * obj0 = 0 ;
37765 char *kwnames[] = {
37766 (char *) "self", NULL
37767 };
37768
37769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
37770 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37771 if (SWIG_arg_fail(1)) SWIG_fail;
37772 {
37773 PyThreadState* __tstate = wxPyBeginAllowThreads();
37774 result = (arg1)->GetFont();
37775
37776 wxPyEndAllowThreads(__tstate);
37777 if (PyErr_Occurred()) SWIG_fail;
37778 }
37779 {
37780 wxFont * resultptr;
37781 resultptr = new wxFont(static_cast<wxFont & >(result));
37782 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
37783 }
37784 return resultobj;
37785 fail:
37786 return NULL;
37787 }
37788
37789
37790 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37791 PyObject *resultobj = NULL;
37792 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37793 wxColour *arg2 = 0 ;
37794 wxColour temp2 ;
37795 PyObject * obj0 = 0 ;
37796 PyObject * obj1 = 0 ;
37797 char *kwnames[] = {
37798 (char *) "self",(char *) "colText", NULL
37799 };
37800
37801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
37802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37803 if (SWIG_arg_fail(1)) SWIG_fail;
37804 {
37805 arg2 = &temp2;
37806 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37807 }
37808 {
37809 PyThreadState* __tstate = wxPyBeginAllowThreads();
37810 (arg1)->SetTextColour((wxColour const &)*arg2);
37811
37812 wxPyEndAllowThreads(__tstate);
37813 if (PyErr_Occurred()) SWIG_fail;
37814 }
37815 Py_INCREF(Py_None); resultobj = Py_None;
37816 return resultobj;
37817 fail:
37818 return NULL;
37819 }
37820
37821
37822 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37823 PyObject *resultobj = NULL;
37824 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37825 wxColour result;
37826 PyObject * obj0 = 0 ;
37827 char *kwnames[] = {
37828 (char *) "self", NULL
37829 };
37830
37831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
37832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37833 if (SWIG_arg_fail(1)) SWIG_fail;
37834 {
37835 PyThreadState* __tstate = wxPyBeginAllowThreads();
37836 result = (arg1)->GetTextColour();
37837
37838 wxPyEndAllowThreads(__tstate);
37839 if (PyErr_Occurred()) SWIG_fail;
37840 }
37841 {
37842 wxColour * resultptr;
37843 resultptr = new wxColour(static_cast<wxColour & >(result));
37844 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37845 }
37846 return resultobj;
37847 fail:
37848 return NULL;
37849 }
37850
37851
37852 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37853 PyObject *resultobj = NULL;
37854 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37855 wxColour *arg2 = 0 ;
37856 wxColour temp2 ;
37857 PyObject * obj0 = 0 ;
37858 PyObject * obj1 = 0 ;
37859 char *kwnames[] = {
37860 (char *) "self",(char *) "colBack", NULL
37861 };
37862
37863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
37864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37865 if (SWIG_arg_fail(1)) SWIG_fail;
37866 {
37867 arg2 = &temp2;
37868 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37869 }
37870 {
37871 PyThreadState* __tstate = wxPyBeginAllowThreads();
37872 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
37873
37874 wxPyEndAllowThreads(__tstate);
37875 if (PyErr_Occurred()) SWIG_fail;
37876 }
37877 Py_INCREF(Py_None); resultobj = Py_None;
37878 return resultobj;
37879 fail:
37880 return NULL;
37881 }
37882
37883
37884 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37885 PyObject *resultobj = NULL;
37886 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37887 wxColour result;
37888 PyObject * obj0 = 0 ;
37889 char *kwnames[] = {
37890 (char *) "self", NULL
37891 };
37892
37893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
37894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37895 if (SWIG_arg_fail(1)) SWIG_fail;
37896 {
37897 PyThreadState* __tstate = wxPyBeginAllowThreads();
37898 result = (arg1)->GetBackgroundColour();
37899
37900 wxPyEndAllowThreads(__tstate);
37901 if (PyErr_Occurred()) SWIG_fail;
37902 }
37903 {
37904 wxColour * resultptr;
37905 resultptr = new wxColour(static_cast<wxColour & >(result));
37906 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37907 }
37908 return resultobj;
37909 fail:
37910 return NULL;
37911 }
37912
37913
37914 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
37915 PyObject *resultobj = NULL;
37916 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37917 wxBitmap *arg2 = 0 ;
37918 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37919 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37920 PyObject * obj0 = 0 ;
37921 PyObject * obj1 = 0 ;
37922 PyObject * obj2 = 0 ;
37923 char *kwnames[] = {
37924 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37925 };
37926
37927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37929 if (SWIG_arg_fail(1)) SWIG_fail;
37930 {
37931 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37932 if (SWIG_arg_fail(2)) SWIG_fail;
37933 if (arg2 == NULL) {
37934 SWIG_null_ref("wxBitmap");
37935 }
37936 if (SWIG_arg_fail(2)) SWIG_fail;
37937 }
37938 if (obj2) {
37939 {
37940 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37941 if (SWIG_arg_fail(3)) SWIG_fail;
37942 if (arg3 == NULL) {
37943 SWIG_null_ref("wxBitmap");
37944 }
37945 if (SWIG_arg_fail(3)) SWIG_fail;
37946 }
37947 }
37948 {
37949 PyThreadState* __tstate = wxPyBeginAllowThreads();
37950 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37951
37952 wxPyEndAllowThreads(__tstate);
37953 if (PyErr_Occurred()) SWIG_fail;
37954 }
37955 Py_INCREF(Py_None); resultobj = Py_None;
37956 return resultobj;
37957 fail:
37958 return NULL;
37959 }
37960
37961
37962 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37963 PyObject *resultobj = NULL;
37964 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37965 wxBitmap *arg2 = 0 ;
37966 PyObject * obj0 = 0 ;
37967 PyObject * obj1 = 0 ;
37968 char *kwnames[] = {
37969 (char *) "self",(char *) "bmpDisabled", NULL
37970 };
37971
37972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37974 if (SWIG_arg_fail(1)) SWIG_fail;
37975 {
37976 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37977 if (SWIG_arg_fail(2)) SWIG_fail;
37978 if (arg2 == NULL) {
37979 SWIG_null_ref("wxBitmap");
37980 }
37981 if (SWIG_arg_fail(2)) SWIG_fail;
37982 }
37983 {
37984 PyThreadState* __tstate = wxPyBeginAllowThreads();
37985 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
37986
37987 wxPyEndAllowThreads(__tstate);
37988 if (PyErr_Occurred()) SWIG_fail;
37989 }
37990 Py_INCREF(Py_None); resultobj = Py_None;
37991 return resultobj;
37992 fail:
37993 return NULL;
37994 }
37995
37996
37997 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37998 PyObject *resultobj = NULL;
37999 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38000 wxBitmap *result;
38001 PyObject * obj0 = 0 ;
38002 char *kwnames[] = {
38003 (char *) "self", NULL
38004 };
38005
38006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
38007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38008 if (SWIG_arg_fail(1)) SWIG_fail;
38009 {
38010 PyThreadState* __tstate = wxPyBeginAllowThreads();
38011 {
38012 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
38013 result = (wxBitmap *) &_result_ref;
38014 }
38015
38016 wxPyEndAllowThreads(__tstate);
38017 if (PyErr_Occurred()) SWIG_fail;
38018 }
38019 {
38020 wxBitmap* resultptr = new wxBitmap(*result);
38021 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
38022 }
38023 return resultobj;
38024 fail:
38025 return NULL;
38026 }
38027
38028
38029 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38030 PyObject *resultobj = NULL;
38031 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38032 int arg2 ;
38033 PyObject * obj0 = 0 ;
38034 PyObject * obj1 = 0 ;
38035 char *kwnames[] = {
38036 (char *) "self",(char *) "nWidth", NULL
38037 };
38038
38039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
38040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38041 if (SWIG_arg_fail(1)) SWIG_fail;
38042 {
38043 arg2 = static_cast<int >(SWIG_As_int(obj1));
38044 if (SWIG_arg_fail(2)) SWIG_fail;
38045 }
38046 {
38047 PyThreadState* __tstate = wxPyBeginAllowThreads();
38048 (arg1)->SetMarginWidth(arg2);
38049
38050 wxPyEndAllowThreads(__tstate);
38051 if (PyErr_Occurred()) SWIG_fail;
38052 }
38053 Py_INCREF(Py_None); resultobj = Py_None;
38054 return resultobj;
38055 fail:
38056 return NULL;
38057 }
38058
38059
38060 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38061 PyObject *resultobj = NULL;
38062 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38063 int result;
38064 PyObject * obj0 = 0 ;
38065 char *kwnames[] = {
38066 (char *) "self", NULL
38067 };
38068
38069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
38070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38071 if (SWIG_arg_fail(1)) SWIG_fail;
38072 {
38073 PyThreadState* __tstate = wxPyBeginAllowThreads();
38074 result = (int)(arg1)->GetMarginWidth();
38075
38076 wxPyEndAllowThreads(__tstate);
38077 if (PyErr_Occurred()) SWIG_fail;
38078 }
38079 {
38080 resultobj = SWIG_From_int(static_cast<int >(result));
38081 }
38082 return resultobj;
38083 fail:
38084 return NULL;
38085 }
38086
38087
38088 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
38089 PyObject *resultobj = NULL;
38090 int result;
38091 char *kwnames[] = {
38092 NULL
38093 };
38094
38095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
38096 {
38097 PyThreadState* __tstate = wxPyBeginAllowThreads();
38098 result = (int)wxMenuItem::GetDefaultMarginWidth();
38099
38100 wxPyEndAllowThreads(__tstate);
38101 if (PyErr_Occurred()) SWIG_fail;
38102 }
38103 {
38104 resultobj = SWIG_From_int(static_cast<int >(result));
38105 }
38106 return resultobj;
38107 fail:
38108 return NULL;
38109 }
38110
38111
38112 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38113 PyObject *resultobj = NULL;
38114 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38115 bool result;
38116 PyObject * obj0 = 0 ;
38117 char *kwnames[] = {
38118 (char *) "self", NULL
38119 };
38120
38121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
38122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38123 if (SWIG_arg_fail(1)) SWIG_fail;
38124 {
38125 PyThreadState* __tstate = wxPyBeginAllowThreads();
38126 result = (bool)(arg1)->IsOwnerDrawn();
38127
38128 wxPyEndAllowThreads(__tstate);
38129 if (PyErr_Occurred()) SWIG_fail;
38130 }
38131 {
38132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38133 }
38134 return resultobj;
38135 fail:
38136 return NULL;
38137 }
38138
38139
38140 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38141 PyObject *resultobj = NULL;
38142 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38143 bool arg2 = (bool) true ;
38144 PyObject * obj0 = 0 ;
38145 PyObject * obj1 = 0 ;
38146 char *kwnames[] = {
38147 (char *) "self",(char *) "ownerDrawn", NULL
38148 };
38149
38150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
38151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38152 if (SWIG_arg_fail(1)) SWIG_fail;
38153 if (obj1) {
38154 {
38155 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
38156 if (SWIG_arg_fail(2)) SWIG_fail;
38157 }
38158 }
38159 {
38160 PyThreadState* __tstate = wxPyBeginAllowThreads();
38161 (arg1)->SetOwnerDrawn(arg2);
38162
38163 wxPyEndAllowThreads(__tstate);
38164 if (PyErr_Occurred()) SWIG_fail;
38165 }
38166 Py_INCREF(Py_None); resultobj = Py_None;
38167 return resultobj;
38168 fail:
38169 return NULL;
38170 }
38171
38172
38173 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
38174 PyObject *resultobj = NULL;
38175 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
38176 PyObject * obj0 = 0 ;
38177 char *kwnames[] = {
38178 (char *) "self", NULL
38179 };
38180
38181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
38182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
38183 if (SWIG_arg_fail(1)) SWIG_fail;
38184 {
38185 PyThreadState* __tstate = wxPyBeginAllowThreads();
38186 (arg1)->ResetOwnerDrawn();
38187
38188 wxPyEndAllowThreads(__tstate);
38189 if (PyErr_Occurred()) SWIG_fail;
38190 }
38191 Py_INCREF(Py_None); resultobj = Py_None;
38192 return resultobj;
38193 fail:
38194 return NULL;
38195 }
38196
38197
38198 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
38199 PyObject *obj;
38200 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38201 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
38202 Py_INCREF(obj);
38203 return Py_BuildValue((char *)"");
38204 }
38205 static int _wrap_ControlNameStr_set(PyObject *) {
38206 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
38207 return 1;
38208 }
38209
38210
38211 static PyObject *_wrap_ControlNameStr_get(void) {
38212 PyObject *pyobj = NULL;
38213
38214 {
38215 #if wxUSE_UNICODE
38216 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
38217 #else
38218 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
38219 #endif
38220 }
38221 return pyobj;
38222 }
38223
38224
38225 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
38226 PyObject *resultobj = NULL;
38227 wxWindow *arg1 = (wxWindow *) 0 ;
38228 int arg2 = (int) -1 ;
38229 wxPoint const &arg3_defvalue = wxDefaultPosition ;
38230 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
38231 wxSize const &arg4_defvalue = wxDefaultSize ;
38232 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
38233 long arg5 = (long) 0 ;
38234 wxValidator const &arg6_defvalue = wxDefaultValidator ;
38235 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
38236 wxString const &arg7_defvalue = wxPyControlNameStr ;
38237 wxString *arg7 = (wxString *) &arg7_defvalue ;
38238 wxControl *result;
38239 wxPoint temp3 ;
38240 wxSize temp4 ;
38241 bool temp7 = false ;
38242 PyObject * obj0 = 0 ;
38243 PyObject * obj1 = 0 ;
38244 PyObject * obj2 = 0 ;
38245 PyObject * obj3 = 0 ;
38246 PyObject * obj4 = 0 ;
38247 PyObject * obj5 = 0 ;
38248 PyObject * obj6 = 0 ;
38249 char *kwnames[] = {
38250 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38251 };
38252
38253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38255 if (SWIG_arg_fail(1)) SWIG_fail;
38256 if (obj1) {
38257 {
38258 arg2 = static_cast<int >(SWIG_As_int(obj1));
38259 if (SWIG_arg_fail(2)) SWIG_fail;
38260 }
38261 }
38262 if (obj2) {
38263 {
38264 arg3 = &temp3;
38265 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
38266 }
38267 }
38268 if (obj3) {
38269 {
38270 arg4 = &temp4;
38271 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
38272 }
38273 }
38274 if (obj4) {
38275 {
38276 arg5 = static_cast<long >(SWIG_As_long(obj4));
38277 if (SWIG_arg_fail(5)) SWIG_fail;
38278 }
38279 }
38280 if (obj5) {
38281 {
38282 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38283 if (SWIG_arg_fail(6)) SWIG_fail;
38284 if (arg6 == NULL) {
38285 SWIG_null_ref("wxValidator");
38286 }
38287 if (SWIG_arg_fail(6)) SWIG_fail;
38288 }
38289 }
38290 if (obj6) {
38291 {
38292 arg7 = wxString_in_helper(obj6);
38293 if (arg7 == NULL) SWIG_fail;
38294 temp7 = true;
38295 }
38296 }
38297 {
38298 if (!wxPyCheckForApp()) SWIG_fail;
38299 PyThreadState* __tstate = wxPyBeginAllowThreads();
38300 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
38301
38302 wxPyEndAllowThreads(__tstate);
38303 if (PyErr_Occurred()) SWIG_fail;
38304 }
38305 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38306 {
38307 if (temp7)
38308 delete arg7;
38309 }
38310 return resultobj;
38311 fail:
38312 {
38313 if (temp7)
38314 delete arg7;
38315 }
38316 return NULL;
38317 }
38318
38319
38320 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
38321 PyObject *resultobj = NULL;
38322 wxControl *result;
38323 char *kwnames[] = {
38324 NULL
38325 };
38326
38327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
38328 {
38329 if (!wxPyCheckForApp()) SWIG_fail;
38330 PyThreadState* __tstate = wxPyBeginAllowThreads();
38331 result = (wxControl *)new wxControl();
38332
38333 wxPyEndAllowThreads(__tstate);
38334 if (PyErr_Occurred()) SWIG_fail;
38335 }
38336 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38337 return resultobj;
38338 fail:
38339 return NULL;
38340 }
38341
38342
38343 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
38344 PyObject *resultobj = NULL;
38345 wxControl *arg1 = (wxControl *) 0 ;
38346 wxWindow *arg2 = (wxWindow *) 0 ;
38347 int arg3 = (int) -1 ;
38348 wxPoint const &arg4_defvalue = wxDefaultPosition ;
38349 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
38350 wxSize const &arg5_defvalue = wxDefaultSize ;
38351 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
38352 long arg6 = (long) 0 ;
38353 wxValidator const &arg7_defvalue = wxDefaultValidator ;
38354 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
38355 wxString const &arg8_defvalue = wxPyControlNameStr ;
38356 wxString *arg8 = (wxString *) &arg8_defvalue ;
38357 bool result;
38358 wxPoint temp4 ;
38359 wxSize temp5 ;
38360 bool temp8 = false ;
38361 PyObject * obj0 = 0 ;
38362 PyObject * obj1 = 0 ;
38363 PyObject * obj2 = 0 ;
38364 PyObject * obj3 = 0 ;
38365 PyObject * obj4 = 0 ;
38366 PyObject * obj5 = 0 ;
38367 PyObject * obj6 = 0 ;
38368 PyObject * obj7 = 0 ;
38369 char *kwnames[] = {
38370 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38371 };
38372
38373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
38374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38375 if (SWIG_arg_fail(1)) SWIG_fail;
38376 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38377 if (SWIG_arg_fail(2)) SWIG_fail;
38378 if (obj2) {
38379 {
38380 arg3 = static_cast<int >(SWIG_As_int(obj2));
38381 if (SWIG_arg_fail(3)) SWIG_fail;
38382 }
38383 }
38384 if (obj3) {
38385 {
38386 arg4 = &temp4;
38387 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
38388 }
38389 }
38390 if (obj4) {
38391 {
38392 arg5 = &temp5;
38393 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
38394 }
38395 }
38396 if (obj5) {
38397 {
38398 arg6 = static_cast<long >(SWIG_As_long(obj5));
38399 if (SWIG_arg_fail(6)) SWIG_fail;
38400 }
38401 }
38402 if (obj6) {
38403 {
38404 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38405 if (SWIG_arg_fail(7)) SWIG_fail;
38406 if (arg7 == NULL) {
38407 SWIG_null_ref("wxValidator");
38408 }
38409 if (SWIG_arg_fail(7)) SWIG_fail;
38410 }
38411 }
38412 if (obj7) {
38413 {
38414 arg8 = wxString_in_helper(obj7);
38415 if (arg8 == NULL) SWIG_fail;
38416 temp8 = true;
38417 }
38418 }
38419 {
38420 PyThreadState* __tstate = wxPyBeginAllowThreads();
38421 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
38422
38423 wxPyEndAllowThreads(__tstate);
38424 if (PyErr_Occurred()) SWIG_fail;
38425 }
38426 {
38427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38428 }
38429 {
38430 if (temp8)
38431 delete arg8;
38432 }
38433 return resultobj;
38434 fail:
38435 {
38436 if (temp8)
38437 delete arg8;
38438 }
38439 return NULL;
38440 }
38441
38442
38443 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
38444 PyObject *resultobj = NULL;
38445 wxControl *arg1 = (wxControl *) 0 ;
38446 wxCommandEvent *arg2 = 0 ;
38447 PyObject * obj0 = 0 ;
38448 PyObject * obj1 = 0 ;
38449 char *kwnames[] = {
38450 (char *) "self",(char *) "event", NULL
38451 };
38452
38453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
38454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38455 if (SWIG_arg_fail(1)) SWIG_fail;
38456 {
38457 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
38458 if (SWIG_arg_fail(2)) SWIG_fail;
38459 if (arg2 == NULL) {
38460 SWIG_null_ref("wxCommandEvent");
38461 }
38462 if (SWIG_arg_fail(2)) SWIG_fail;
38463 }
38464 {
38465 PyThreadState* __tstate = wxPyBeginAllowThreads();
38466 (arg1)->Command(*arg2);
38467
38468 wxPyEndAllowThreads(__tstate);
38469 if (PyErr_Occurred()) SWIG_fail;
38470 }
38471 Py_INCREF(Py_None); resultobj = Py_None;
38472 return resultobj;
38473 fail:
38474 return NULL;
38475 }
38476
38477
38478 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38479 PyObject *resultobj = NULL;
38480 wxControl *arg1 = (wxControl *) 0 ;
38481 wxString result;
38482 PyObject * obj0 = 0 ;
38483 char *kwnames[] = {
38484 (char *) "self", NULL
38485 };
38486
38487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
38488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38489 if (SWIG_arg_fail(1)) SWIG_fail;
38490 {
38491 PyThreadState* __tstate = wxPyBeginAllowThreads();
38492 result = (arg1)->GetLabel();
38493
38494 wxPyEndAllowThreads(__tstate);
38495 if (PyErr_Occurred()) SWIG_fail;
38496 }
38497 {
38498 #if wxUSE_UNICODE
38499 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38500 #else
38501 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38502 #endif
38503 }
38504 return resultobj;
38505 fail:
38506 return NULL;
38507 }
38508
38509
38510 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38511 PyObject *resultobj = NULL;
38512 wxControl *arg1 = (wxControl *) 0 ;
38513 wxString *arg2 = 0 ;
38514 bool temp2 = false ;
38515 PyObject * obj0 = 0 ;
38516 PyObject * obj1 = 0 ;
38517 char *kwnames[] = {
38518 (char *) "self",(char *) "label", NULL
38519 };
38520
38521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
38522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38523 if (SWIG_arg_fail(1)) SWIG_fail;
38524 {
38525 arg2 = wxString_in_helper(obj1);
38526 if (arg2 == NULL) SWIG_fail;
38527 temp2 = true;
38528 }
38529 {
38530 PyThreadState* __tstate = wxPyBeginAllowThreads();
38531 (arg1)->SetLabel((wxString const &)*arg2);
38532
38533 wxPyEndAllowThreads(__tstate);
38534 if (PyErr_Occurred()) SWIG_fail;
38535 }
38536 Py_INCREF(Py_None); resultobj = Py_None;
38537 {
38538 if (temp2)
38539 delete arg2;
38540 }
38541 return resultobj;
38542 fail:
38543 {
38544 if (temp2)
38545 delete arg2;
38546 }
38547 return NULL;
38548 }
38549
38550
38551 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
38552 PyObject *resultobj = NULL;
38553 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38554 wxVisualAttributes result;
38555 PyObject * obj0 = 0 ;
38556 char *kwnames[] = {
38557 (char *) "variant", NULL
38558 };
38559
38560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
38561 if (obj0) {
38562 {
38563 arg1 = static_cast<wxWindowVariant >(SWIG_As_int(obj0));
38564 if (SWIG_arg_fail(1)) SWIG_fail;
38565 }
38566 }
38567 {
38568 if (!wxPyCheckForApp()) SWIG_fail;
38569 PyThreadState* __tstate = wxPyBeginAllowThreads();
38570 result = wxControl::GetClassDefaultAttributes(arg1);
38571
38572 wxPyEndAllowThreads(__tstate);
38573 if (PyErr_Occurred()) SWIG_fail;
38574 }
38575 {
38576 wxVisualAttributes * resultptr;
38577 resultptr = new wxVisualAttributes(static_cast<wxVisualAttributes & >(result));
38578 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
38579 }
38580 return resultobj;
38581 fail:
38582 return NULL;
38583 }
38584
38585
38586 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
38587 PyObject *obj;
38588 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38589 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
38590 Py_INCREF(obj);
38591 return Py_BuildValue((char *)"");
38592 }
38593 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
38594 PyObject *resultobj = NULL;
38595 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38596 wxString *arg2 = 0 ;
38597 PyObject *arg3 = (PyObject *) NULL ;
38598 int result;
38599 bool temp2 = false ;
38600 PyObject * obj0 = 0 ;
38601 PyObject * obj1 = 0 ;
38602 PyObject * obj2 = 0 ;
38603 char *kwnames[] = {
38604 (char *) "self",(char *) "item",(char *) "clientData", NULL
38605 };
38606
38607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
38608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38609 if (SWIG_arg_fail(1)) SWIG_fail;
38610 {
38611 arg2 = wxString_in_helper(obj1);
38612 if (arg2 == NULL) SWIG_fail;
38613 temp2 = true;
38614 }
38615 if (obj2) {
38616 arg3 = obj2;
38617 }
38618 {
38619 PyThreadState* __tstate = wxPyBeginAllowThreads();
38620 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
38621
38622 wxPyEndAllowThreads(__tstate);
38623 if (PyErr_Occurred()) SWIG_fail;
38624 }
38625 {
38626 resultobj = SWIG_From_int(static_cast<int >(result));
38627 }
38628 {
38629 if (temp2)
38630 delete arg2;
38631 }
38632 return resultobj;
38633 fail:
38634 {
38635 if (temp2)
38636 delete arg2;
38637 }
38638 return NULL;
38639 }
38640
38641
38642 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
38643 PyObject *resultobj = NULL;
38644 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38645 wxArrayString *arg2 = 0 ;
38646 bool temp2 = false ;
38647 PyObject * obj0 = 0 ;
38648 PyObject * obj1 = 0 ;
38649 char *kwnames[] = {
38650 (char *) "self",(char *) "strings", NULL
38651 };
38652
38653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
38654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38655 if (SWIG_arg_fail(1)) SWIG_fail;
38656 {
38657 if (! PySequence_Check(obj1)) {
38658 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38659 SWIG_fail;
38660 }
38661 arg2 = new wxArrayString;
38662 temp2 = true;
38663 int i, len=PySequence_Length(obj1);
38664 for (i=0; i<len; i++) {
38665 PyObject* item = PySequence_GetItem(obj1, i);
38666 wxString* s = wxString_in_helper(item);
38667 if (PyErr_Occurred()) SWIG_fail;
38668 arg2->Add(*s);
38669 delete s;
38670 Py_DECREF(item);
38671 }
38672 }
38673 {
38674 PyThreadState* __tstate = wxPyBeginAllowThreads();
38675 (arg1)->Append((wxArrayString const &)*arg2);
38676
38677 wxPyEndAllowThreads(__tstate);
38678 if (PyErr_Occurred()) SWIG_fail;
38679 }
38680 Py_INCREF(Py_None); resultobj = Py_None;
38681 {
38682 if (temp2) delete arg2;
38683 }
38684 return resultobj;
38685 fail:
38686 {
38687 if (temp2) delete arg2;
38688 }
38689 return NULL;
38690 }
38691
38692
38693 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38694 PyObject *resultobj = NULL;
38695 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38696 wxString *arg2 = 0 ;
38697 int arg3 ;
38698 PyObject *arg4 = (PyObject *) NULL ;
38699 int result;
38700 bool temp2 = false ;
38701 PyObject * obj0 = 0 ;
38702 PyObject * obj1 = 0 ;
38703 PyObject * obj2 = 0 ;
38704 PyObject * obj3 = 0 ;
38705 char *kwnames[] = {
38706 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
38707 };
38708
38709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
38710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38711 if (SWIG_arg_fail(1)) SWIG_fail;
38712 {
38713 arg2 = wxString_in_helper(obj1);
38714 if (arg2 == NULL) SWIG_fail;
38715 temp2 = true;
38716 }
38717 {
38718 arg3 = static_cast<int >(SWIG_As_int(obj2));
38719 if (SWIG_arg_fail(3)) SWIG_fail;
38720 }
38721 if (obj3) {
38722 arg4 = obj3;
38723 }
38724 {
38725 PyThreadState* __tstate = wxPyBeginAllowThreads();
38726 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
38727
38728 wxPyEndAllowThreads(__tstate);
38729 if (PyErr_Occurred()) SWIG_fail;
38730 }
38731 {
38732 resultobj = SWIG_From_int(static_cast<int >(result));
38733 }
38734 {
38735 if (temp2)
38736 delete arg2;
38737 }
38738 return resultobj;
38739 fail:
38740 {
38741 if (temp2)
38742 delete arg2;
38743 }
38744 return NULL;
38745 }
38746
38747
38748 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
38749 PyObject *resultobj = NULL;
38750 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38751 PyObject * obj0 = 0 ;
38752 char *kwnames[] = {
38753 (char *) "self", NULL
38754 };
38755
38756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
38757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38758 if (SWIG_arg_fail(1)) SWIG_fail;
38759 {
38760 PyThreadState* __tstate = wxPyBeginAllowThreads();
38761 (arg1)->Clear();
38762
38763 wxPyEndAllowThreads(__tstate);
38764 if (PyErr_Occurred()) SWIG_fail;
38765 }
38766 Py_INCREF(Py_None); resultobj = Py_None;
38767 return resultobj;
38768 fail:
38769 return NULL;
38770 }
38771
38772
38773 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
38774 PyObject *resultobj = NULL;
38775 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38776 int arg2 ;
38777 PyObject * obj0 = 0 ;
38778 PyObject * obj1 = 0 ;
38779 char *kwnames[] = {
38780 (char *) "self",(char *) "n", NULL
38781 };
38782
38783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
38784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38785 if (SWIG_arg_fail(1)) SWIG_fail;
38786 {
38787 arg2 = static_cast<int >(SWIG_As_int(obj1));
38788 if (SWIG_arg_fail(2)) SWIG_fail;
38789 }
38790 {
38791 PyThreadState* __tstate = wxPyBeginAllowThreads();
38792 (arg1)->Delete(arg2);
38793
38794 wxPyEndAllowThreads(__tstate);
38795 if (PyErr_Occurred()) SWIG_fail;
38796 }
38797 Py_INCREF(Py_None); resultobj = Py_None;
38798 return resultobj;
38799 fail:
38800 return NULL;
38801 }
38802
38803
38804 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38805 PyObject *resultobj = NULL;
38806 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38807 int arg2 ;
38808 PyObject *result;
38809 PyObject * obj0 = 0 ;
38810 PyObject * obj1 = 0 ;
38811 char *kwnames[] = {
38812 (char *) "self",(char *) "n", NULL
38813 };
38814
38815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
38816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38817 if (SWIG_arg_fail(1)) SWIG_fail;
38818 {
38819 arg2 = static_cast<int >(SWIG_As_int(obj1));
38820 if (SWIG_arg_fail(2)) SWIG_fail;
38821 }
38822 {
38823 PyThreadState* __tstate = wxPyBeginAllowThreads();
38824 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
38825
38826 wxPyEndAllowThreads(__tstate);
38827 if (PyErr_Occurred()) SWIG_fail;
38828 }
38829 resultobj = result;
38830 return resultobj;
38831 fail:
38832 return NULL;
38833 }
38834
38835
38836 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38837 PyObject *resultobj = NULL;
38838 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38839 int arg2 ;
38840 PyObject *arg3 = (PyObject *) 0 ;
38841 PyObject * obj0 = 0 ;
38842 PyObject * obj1 = 0 ;
38843 PyObject * obj2 = 0 ;
38844 char *kwnames[] = {
38845 (char *) "self",(char *) "n",(char *) "clientData", NULL
38846 };
38847
38848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38850 if (SWIG_arg_fail(1)) SWIG_fail;
38851 {
38852 arg2 = static_cast<int >(SWIG_As_int(obj1));
38853 if (SWIG_arg_fail(2)) SWIG_fail;
38854 }
38855 arg3 = obj2;
38856 {
38857 PyThreadState* __tstate = wxPyBeginAllowThreads();
38858 wxItemContainer_SetClientData(arg1,arg2,arg3);
38859
38860 wxPyEndAllowThreads(__tstate);
38861 if (PyErr_Occurred()) SWIG_fail;
38862 }
38863 Py_INCREF(Py_None); resultobj = Py_None;
38864 return resultobj;
38865 fail:
38866 return NULL;
38867 }
38868
38869
38870 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38871 PyObject *resultobj = NULL;
38872 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38873 int result;
38874 PyObject * obj0 = 0 ;
38875 char *kwnames[] = {
38876 (char *) "self", NULL
38877 };
38878
38879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38881 if (SWIG_arg_fail(1)) SWIG_fail;
38882 {
38883 PyThreadState* __tstate = wxPyBeginAllowThreads();
38884 result = (int)((wxItemContainer const *)arg1)->GetCount();
38885
38886 wxPyEndAllowThreads(__tstate);
38887 if (PyErr_Occurred()) SWIG_fail;
38888 }
38889 {
38890 resultobj = SWIG_From_int(static_cast<int >(result));
38891 }
38892 return resultobj;
38893 fail:
38894 return NULL;
38895 }
38896
38897
38898 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38899 PyObject *resultobj = NULL;
38900 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38901 bool result;
38902 PyObject * obj0 = 0 ;
38903 char *kwnames[] = {
38904 (char *) "self", NULL
38905 };
38906
38907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38909 if (SWIG_arg_fail(1)) SWIG_fail;
38910 {
38911 PyThreadState* __tstate = wxPyBeginAllowThreads();
38912 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38913
38914 wxPyEndAllowThreads(__tstate);
38915 if (PyErr_Occurred()) SWIG_fail;
38916 }
38917 {
38918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38919 }
38920 return resultobj;
38921 fail:
38922 return NULL;
38923 }
38924
38925
38926 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38927 PyObject *resultobj = NULL;
38928 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38929 int arg2 ;
38930 wxString result;
38931 PyObject * obj0 = 0 ;
38932 PyObject * obj1 = 0 ;
38933 char *kwnames[] = {
38934 (char *) "self",(char *) "n", NULL
38935 };
38936
38937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38939 if (SWIG_arg_fail(1)) SWIG_fail;
38940 {
38941 arg2 = static_cast<int >(SWIG_As_int(obj1));
38942 if (SWIG_arg_fail(2)) SWIG_fail;
38943 }
38944 {
38945 PyThreadState* __tstate = wxPyBeginAllowThreads();
38946 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38947
38948 wxPyEndAllowThreads(__tstate);
38949 if (PyErr_Occurred()) SWIG_fail;
38950 }
38951 {
38952 #if wxUSE_UNICODE
38953 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38954 #else
38955 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38956 #endif
38957 }
38958 return resultobj;
38959 fail:
38960 return NULL;
38961 }
38962
38963
38964 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38965 PyObject *resultobj = NULL;
38966 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38967 wxArrayString result;
38968 PyObject * obj0 = 0 ;
38969 char *kwnames[] = {
38970 (char *) "self", NULL
38971 };
38972
38973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38975 if (SWIG_arg_fail(1)) SWIG_fail;
38976 {
38977 PyThreadState* __tstate = wxPyBeginAllowThreads();
38978 result = ((wxItemContainer const *)arg1)->GetStrings();
38979
38980 wxPyEndAllowThreads(__tstate);
38981 if (PyErr_Occurred()) SWIG_fail;
38982 }
38983 {
38984 resultobj = wxArrayString2PyList_helper(result);
38985 }
38986 return resultobj;
38987 fail:
38988 return NULL;
38989 }
38990
38991
38992 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38993 PyObject *resultobj = NULL;
38994 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38995 int arg2 ;
38996 wxString *arg3 = 0 ;
38997 bool temp3 = false ;
38998 PyObject * obj0 = 0 ;
38999 PyObject * obj1 = 0 ;
39000 PyObject * obj2 = 0 ;
39001 char *kwnames[] = {
39002 (char *) "self",(char *) "n",(char *) "s", NULL
39003 };
39004
39005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
39006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39007 if (SWIG_arg_fail(1)) SWIG_fail;
39008 {
39009 arg2 = static_cast<int >(SWIG_As_int(obj1));
39010 if (SWIG_arg_fail(2)) SWIG_fail;
39011 }
39012 {
39013 arg3 = wxString_in_helper(obj2);
39014 if (arg3 == NULL) SWIG_fail;
39015 temp3 = true;
39016 }
39017 {
39018 PyThreadState* __tstate = wxPyBeginAllowThreads();
39019 (arg1)->SetString(arg2,(wxString const &)*arg3);
39020
39021 wxPyEndAllowThreads(__tstate);
39022 if (PyErr_Occurred()) SWIG_fail;
39023 }
39024 Py_INCREF(Py_None); resultobj = Py_None;
39025 {
39026 if (temp3)
39027 delete arg3;
39028 }
39029 return resultobj;
39030 fail:
39031 {
39032 if (temp3)
39033 delete arg3;
39034 }
39035 return NULL;
39036 }
39037
39038
39039 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
39040 PyObject *resultobj = NULL;
39041 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39042 wxString *arg2 = 0 ;
39043 int result;
39044 bool temp2 = false ;
39045 PyObject * obj0 = 0 ;
39046 PyObject * obj1 = 0 ;
39047 char *kwnames[] = {
39048 (char *) "self",(char *) "s", NULL
39049 };
39050
39051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
39052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39053 if (SWIG_arg_fail(1)) SWIG_fail;
39054 {
39055 arg2 = wxString_in_helper(obj1);
39056 if (arg2 == NULL) SWIG_fail;
39057 temp2 = true;
39058 }
39059 {
39060 PyThreadState* __tstate = wxPyBeginAllowThreads();
39061 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
39062
39063 wxPyEndAllowThreads(__tstate);
39064 if (PyErr_Occurred()) SWIG_fail;
39065 }
39066 {
39067 resultobj = SWIG_From_int(static_cast<int >(result));
39068 }
39069 {
39070 if (temp2)
39071 delete arg2;
39072 }
39073 return resultobj;
39074 fail:
39075 {
39076 if (temp2)
39077 delete arg2;
39078 }
39079 return NULL;
39080 }
39081
39082
39083 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39084 PyObject *resultobj = NULL;
39085 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39086 int arg2 ;
39087 PyObject * obj0 = 0 ;
39088 PyObject * obj1 = 0 ;
39089 char *kwnames[] = {
39090 (char *) "self",(char *) "n", NULL
39091 };
39092
39093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
39094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39095 if (SWIG_arg_fail(1)) SWIG_fail;
39096 {
39097 arg2 = static_cast<int >(SWIG_As_int(obj1));
39098 if (SWIG_arg_fail(2)) SWIG_fail;
39099 }
39100 {
39101 PyThreadState* __tstate = wxPyBeginAllowThreads();
39102 (arg1)->SetSelection(arg2);
39103
39104 wxPyEndAllowThreads(__tstate);
39105 if (PyErr_Occurred()) SWIG_fail;
39106 }
39107 Py_INCREF(Py_None); resultobj = Py_None;
39108 return resultobj;
39109 fail:
39110 return NULL;
39111 }
39112
39113
39114 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39115 PyObject *resultobj = NULL;
39116 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39117 int result;
39118 PyObject * obj0 = 0 ;
39119 char *kwnames[] = {
39120 (char *) "self", NULL
39121 };
39122
39123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
39124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39125 if (SWIG_arg_fail(1)) SWIG_fail;
39126 {
39127 PyThreadState* __tstate = wxPyBeginAllowThreads();
39128 result = (int)((wxItemContainer const *)arg1)->GetSelection();
39129
39130 wxPyEndAllowThreads(__tstate);
39131 if (PyErr_Occurred()) SWIG_fail;
39132 }
39133 {
39134 resultobj = SWIG_From_int(static_cast<int >(result));
39135 }
39136 return resultobj;
39137 fail:
39138 return NULL;
39139 }
39140
39141
39142 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39143 PyObject *resultobj = NULL;
39144 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39145 wxString *arg2 = 0 ;
39146 bool result;
39147 bool temp2 = false ;
39148 PyObject * obj0 = 0 ;
39149 PyObject * obj1 = 0 ;
39150 char *kwnames[] = {
39151 (char *) "self",(char *) "s", NULL
39152 };
39153
39154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
39155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39156 if (SWIG_arg_fail(1)) SWIG_fail;
39157 {
39158 arg2 = wxString_in_helper(obj1);
39159 if (arg2 == NULL) SWIG_fail;
39160 temp2 = true;
39161 }
39162 {
39163 PyThreadState* __tstate = wxPyBeginAllowThreads();
39164 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
39165
39166 wxPyEndAllowThreads(__tstate);
39167 if (PyErr_Occurred()) SWIG_fail;
39168 }
39169 {
39170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39171 }
39172 {
39173 if (temp2)
39174 delete arg2;
39175 }
39176 return resultobj;
39177 fail:
39178 {
39179 if (temp2)
39180 delete arg2;
39181 }
39182 return NULL;
39183 }
39184
39185
39186 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
39187 PyObject *resultobj = NULL;
39188 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39189 wxString result;
39190 PyObject * obj0 = 0 ;
39191 char *kwnames[] = {
39192 (char *) "self", NULL
39193 };
39194
39195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
39196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39197 if (SWIG_arg_fail(1)) SWIG_fail;
39198 {
39199 PyThreadState* __tstate = wxPyBeginAllowThreads();
39200 result = ((wxItemContainer const *)arg1)->GetStringSelection();
39201
39202 wxPyEndAllowThreads(__tstate);
39203 if (PyErr_Occurred()) SWIG_fail;
39204 }
39205 {
39206 #if wxUSE_UNICODE
39207 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39208 #else
39209 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39210 #endif
39211 }
39212 return resultobj;
39213 fail:
39214 return NULL;
39215 }
39216
39217
39218 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
39219 PyObject *resultobj = NULL;
39220 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
39221 int arg2 ;
39222 PyObject * obj0 = 0 ;
39223 PyObject * obj1 = 0 ;
39224 char *kwnames[] = {
39225 (char *) "self",(char *) "n", NULL
39226 };
39227
39228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
39229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
39230 if (SWIG_arg_fail(1)) SWIG_fail;
39231 {
39232 arg2 = static_cast<int >(SWIG_As_int(obj1));
39233 if (SWIG_arg_fail(2)) SWIG_fail;
39234 }
39235 {
39236 PyThreadState* __tstate = wxPyBeginAllowThreads();
39237 (arg1)->Select(arg2);
39238
39239 wxPyEndAllowThreads(__tstate);
39240 if (PyErr_Occurred()) SWIG_fail;
39241 }
39242 Py_INCREF(Py_None); resultobj = Py_None;
39243 return resultobj;
39244 fail:
39245 return NULL;
39246 }
39247
39248
39249 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
39250 PyObject *obj;
39251 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39252 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
39253 Py_INCREF(obj);
39254 return Py_BuildValue((char *)"");
39255 }
39256 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
39257 PyObject *obj;
39258 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39259 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
39260 Py_INCREF(obj);
39261 return Py_BuildValue((char *)"");
39262 }
39263 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
39264 PyObject *resultobj = NULL;
39265 wxSizerItem *result;
39266 char *kwnames[] = {
39267 NULL
39268 };
39269
39270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
39271 {
39272 PyThreadState* __tstate = wxPyBeginAllowThreads();
39273 result = (wxSizerItem *)new wxSizerItem();
39274
39275 wxPyEndAllowThreads(__tstate);
39276 if (PyErr_Occurred()) SWIG_fail;
39277 }
39278 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39279 return resultobj;
39280 fail:
39281 return NULL;
39282 }
39283
39284
39285 static PyObject *_wrap_delete_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
39286 PyObject *resultobj = NULL;
39287 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39288 PyObject * obj0 = 0 ;
39289 char *kwnames[] = {
39290 (char *) "self", NULL
39291 };
39292
39293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_SizerItem",kwnames,&obj0)) goto fail;
39294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39295 if (SWIG_arg_fail(1)) SWIG_fail;
39296 {
39297 PyThreadState* __tstate = wxPyBeginAllowThreads();
39298 delete arg1;
39299
39300 wxPyEndAllowThreads(__tstate);
39301 if (PyErr_Occurred()) SWIG_fail;
39302 }
39303 Py_INCREF(Py_None); resultobj = Py_None;
39304 return resultobj;
39305 fail:
39306 return NULL;
39307 }
39308
39309
39310 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39311 PyObject *resultobj = NULL;
39312 wxWindow *arg1 = (wxWindow *) 0 ;
39313 int arg2 ;
39314 int arg3 ;
39315 int arg4 ;
39316 PyObject *arg5 = (PyObject *) NULL ;
39317 wxSizerItem *result;
39318 PyObject * obj0 = 0 ;
39319 PyObject * obj1 = 0 ;
39320 PyObject * obj2 = 0 ;
39321 PyObject * obj3 = 0 ;
39322 PyObject * obj4 = 0 ;
39323 char *kwnames[] = {
39324 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39325 };
39326
39327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39329 if (SWIG_arg_fail(1)) SWIG_fail;
39330 {
39331 arg2 = static_cast<int >(SWIG_As_int(obj1));
39332 if (SWIG_arg_fail(2)) SWIG_fail;
39333 }
39334 {
39335 arg3 = static_cast<int >(SWIG_As_int(obj2));
39336 if (SWIG_arg_fail(3)) SWIG_fail;
39337 }
39338 {
39339 arg4 = static_cast<int >(SWIG_As_int(obj3));
39340 if (SWIG_arg_fail(4)) SWIG_fail;
39341 }
39342 if (obj4) {
39343 arg5 = obj4;
39344 }
39345 {
39346 PyThreadState* __tstate = wxPyBeginAllowThreads();
39347 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39348
39349 wxPyEndAllowThreads(__tstate);
39350 if (PyErr_Occurred()) SWIG_fail;
39351 }
39352 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39353 return resultobj;
39354 fail:
39355 return NULL;
39356 }
39357
39358
39359 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39360 PyObject *resultobj = NULL;
39361 int arg1 ;
39362 int arg2 ;
39363 int arg3 ;
39364 int arg4 ;
39365 int arg5 ;
39366 PyObject *arg6 = (PyObject *) NULL ;
39367 wxSizerItem *result;
39368 PyObject * obj0 = 0 ;
39369 PyObject * obj1 = 0 ;
39370 PyObject * obj2 = 0 ;
39371 PyObject * obj3 = 0 ;
39372 PyObject * obj4 = 0 ;
39373 PyObject * obj5 = 0 ;
39374 char *kwnames[] = {
39375 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39376 };
39377
39378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39379 {
39380 arg1 = static_cast<int >(SWIG_As_int(obj0));
39381 if (SWIG_arg_fail(1)) SWIG_fail;
39382 }
39383 {
39384 arg2 = static_cast<int >(SWIG_As_int(obj1));
39385 if (SWIG_arg_fail(2)) SWIG_fail;
39386 }
39387 {
39388 arg3 = static_cast<int >(SWIG_As_int(obj2));
39389 if (SWIG_arg_fail(3)) SWIG_fail;
39390 }
39391 {
39392 arg4 = static_cast<int >(SWIG_As_int(obj3));
39393 if (SWIG_arg_fail(4)) SWIG_fail;
39394 }
39395 {
39396 arg5 = static_cast<int >(SWIG_As_int(obj4));
39397 if (SWIG_arg_fail(5)) SWIG_fail;
39398 }
39399 if (obj5) {
39400 arg6 = obj5;
39401 }
39402 {
39403 PyThreadState* __tstate = wxPyBeginAllowThreads();
39404 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
39405
39406 wxPyEndAllowThreads(__tstate);
39407 if (PyErr_Occurred()) SWIG_fail;
39408 }
39409 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39410 return resultobj;
39411 fail:
39412 return NULL;
39413 }
39414
39415
39416 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39417 PyObject *resultobj = NULL;
39418 wxSizer *arg1 = (wxSizer *) 0 ;
39419 int arg2 ;
39420 int arg3 ;
39421 int arg4 ;
39422 PyObject *arg5 = (PyObject *) NULL ;
39423 wxSizerItem *result;
39424 PyObject * obj0 = 0 ;
39425 PyObject * obj1 = 0 ;
39426 PyObject * obj2 = 0 ;
39427 PyObject * obj3 = 0 ;
39428 PyObject * obj4 = 0 ;
39429 char *kwnames[] = {
39430 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39431 };
39432
39433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
39435 if (SWIG_arg_fail(1)) SWIG_fail;
39436 {
39437 arg2 = static_cast<int >(SWIG_As_int(obj1));
39438 if (SWIG_arg_fail(2)) SWIG_fail;
39439 }
39440 {
39441 arg3 = static_cast<int >(SWIG_As_int(obj2));
39442 if (SWIG_arg_fail(3)) SWIG_fail;
39443 }
39444 {
39445 arg4 = static_cast<int >(SWIG_As_int(obj3));
39446 if (SWIG_arg_fail(4)) SWIG_fail;
39447 }
39448 if (obj4) {
39449 arg5 = obj4;
39450 }
39451 {
39452 PyThreadState* __tstate = wxPyBeginAllowThreads();
39453 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39454
39455 wxPyEndAllowThreads(__tstate);
39456 if (PyErr_Occurred()) SWIG_fail;
39457 }
39458 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39459 return resultobj;
39460 fail:
39461 return NULL;
39462 }
39463
39464
39465 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39466 PyObject *resultobj = NULL;
39467 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39468 PyObject * obj0 = 0 ;
39469 char *kwnames[] = {
39470 (char *) "self", NULL
39471 };
39472
39473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
39474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39475 if (SWIG_arg_fail(1)) SWIG_fail;
39476 {
39477 PyThreadState* __tstate = wxPyBeginAllowThreads();
39478 (arg1)->DeleteWindows();
39479
39480 wxPyEndAllowThreads(__tstate);
39481 if (PyErr_Occurred()) SWIG_fail;
39482 }
39483 Py_INCREF(Py_None); resultobj = Py_None;
39484 return resultobj;
39485 fail:
39486 return NULL;
39487 }
39488
39489
39490 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39491 PyObject *resultobj = NULL;
39492 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39493 PyObject * obj0 = 0 ;
39494 char *kwnames[] = {
39495 (char *) "self", NULL
39496 };
39497
39498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
39499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39500 if (SWIG_arg_fail(1)) SWIG_fail;
39501 {
39502 PyThreadState* __tstate = wxPyBeginAllowThreads();
39503 (arg1)->DetachSizer();
39504
39505 wxPyEndAllowThreads(__tstate);
39506 if (PyErr_Occurred()) SWIG_fail;
39507 }
39508 Py_INCREF(Py_None); resultobj = Py_None;
39509 return resultobj;
39510 fail:
39511 return NULL;
39512 }
39513
39514
39515 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39516 PyObject *resultobj = NULL;
39517 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39518 wxSize result;
39519 PyObject * obj0 = 0 ;
39520 char *kwnames[] = {
39521 (char *) "self", NULL
39522 };
39523
39524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
39525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39526 if (SWIG_arg_fail(1)) SWIG_fail;
39527 {
39528 PyThreadState* __tstate = wxPyBeginAllowThreads();
39529 result = (arg1)->GetSize();
39530
39531 wxPyEndAllowThreads(__tstate);
39532 if (PyErr_Occurred()) SWIG_fail;
39533 }
39534 {
39535 wxSize * resultptr;
39536 resultptr = new wxSize(static_cast<wxSize & >(result));
39537 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39538 }
39539 return resultobj;
39540 fail:
39541 return NULL;
39542 }
39543
39544
39545 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39546 PyObject *resultobj = NULL;
39547 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39548 wxSize result;
39549 PyObject * obj0 = 0 ;
39550 char *kwnames[] = {
39551 (char *) "self", NULL
39552 };
39553
39554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
39555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39556 if (SWIG_arg_fail(1)) SWIG_fail;
39557 {
39558 PyThreadState* __tstate = wxPyBeginAllowThreads();
39559 result = (arg1)->CalcMin();
39560
39561 wxPyEndAllowThreads(__tstate);
39562 if (PyErr_Occurred()) SWIG_fail;
39563 }
39564 {
39565 wxSize * resultptr;
39566 resultptr = new wxSize(static_cast<wxSize & >(result));
39567 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39568 }
39569 return resultobj;
39570 fail:
39571 return NULL;
39572 }
39573
39574
39575 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39576 PyObject *resultobj = NULL;
39577 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39578 wxPoint *arg2 = 0 ;
39579 wxSize *arg3 = 0 ;
39580 wxPoint temp2 ;
39581 wxSize temp3 ;
39582 PyObject * obj0 = 0 ;
39583 PyObject * obj1 = 0 ;
39584 PyObject * obj2 = 0 ;
39585 char *kwnames[] = {
39586 (char *) "self",(char *) "pos",(char *) "size", NULL
39587 };
39588
39589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
39590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39591 if (SWIG_arg_fail(1)) SWIG_fail;
39592 {
39593 arg2 = &temp2;
39594 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39595 }
39596 {
39597 arg3 = &temp3;
39598 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39599 }
39600 {
39601 PyThreadState* __tstate = wxPyBeginAllowThreads();
39602 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
39603
39604 wxPyEndAllowThreads(__tstate);
39605 if (PyErr_Occurred()) SWIG_fail;
39606 }
39607 Py_INCREF(Py_None); resultobj = Py_None;
39608 return resultobj;
39609 fail:
39610 return NULL;
39611 }
39612
39613
39614 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39615 PyObject *resultobj = NULL;
39616 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39617 wxSize result;
39618 PyObject * obj0 = 0 ;
39619 char *kwnames[] = {
39620 (char *) "self", NULL
39621 };
39622
39623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
39624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39625 if (SWIG_arg_fail(1)) SWIG_fail;
39626 {
39627 PyThreadState* __tstate = wxPyBeginAllowThreads();
39628 result = (arg1)->GetMinSize();
39629
39630 wxPyEndAllowThreads(__tstate);
39631 if (PyErr_Occurred()) SWIG_fail;
39632 }
39633 {
39634 wxSize * resultptr;
39635 resultptr = new wxSize(static_cast<wxSize & >(result));
39636 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39637 }
39638 return resultobj;
39639 fail:
39640 return NULL;
39641 }
39642
39643
39644 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39645 PyObject *resultobj = NULL;
39646 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39647 wxSize result;
39648 PyObject * obj0 = 0 ;
39649 char *kwnames[] = {
39650 (char *) "self", NULL
39651 };
39652
39653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
39654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39655 if (SWIG_arg_fail(1)) SWIG_fail;
39656 {
39657 PyThreadState* __tstate = wxPyBeginAllowThreads();
39658 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
39659
39660 wxPyEndAllowThreads(__tstate);
39661 if (PyErr_Occurred()) SWIG_fail;
39662 }
39663 {
39664 wxSize * resultptr;
39665 resultptr = new wxSize(static_cast<wxSize & >(result));
39666 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39667 }
39668 return resultobj;
39669 fail:
39670 return NULL;
39671 }
39672
39673
39674 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
39675 PyObject *resultobj = NULL;
39676 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39677 int arg2 ;
39678 int arg3 ;
39679 PyObject * obj0 = 0 ;
39680 PyObject * obj1 = 0 ;
39681 PyObject * obj2 = 0 ;
39682 char *kwnames[] = {
39683 (char *) "self",(char *) "x",(char *) "y", NULL
39684 };
39685
39686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39688 if (SWIG_arg_fail(1)) SWIG_fail;
39689 {
39690 arg2 = static_cast<int >(SWIG_As_int(obj1));
39691 if (SWIG_arg_fail(2)) SWIG_fail;
39692 }
39693 {
39694 arg3 = static_cast<int >(SWIG_As_int(obj2));
39695 if (SWIG_arg_fail(3)) SWIG_fail;
39696 }
39697 {
39698 PyThreadState* __tstate = wxPyBeginAllowThreads();
39699 (arg1)->SetInitSize(arg2,arg3);
39700
39701 wxPyEndAllowThreads(__tstate);
39702 if (PyErr_Occurred()) SWIG_fail;
39703 }
39704 Py_INCREF(Py_None); resultobj = Py_None;
39705 return resultobj;
39706 fail:
39707 return NULL;
39708 }
39709
39710
39711 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
39712 PyObject *resultobj = NULL;
39713 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39714 int arg2 ;
39715 int arg3 ;
39716 PyObject * obj0 = 0 ;
39717 PyObject * obj1 = 0 ;
39718 PyObject * obj2 = 0 ;
39719 char *kwnames[] = {
39720 (char *) "self",(char *) "width",(char *) "height", NULL
39721 };
39722
39723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
39724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39725 if (SWIG_arg_fail(1)) SWIG_fail;
39726 {
39727 arg2 = static_cast<int >(SWIG_As_int(obj1));
39728 if (SWIG_arg_fail(2)) SWIG_fail;
39729 }
39730 {
39731 arg3 = static_cast<int >(SWIG_As_int(obj2));
39732 if (SWIG_arg_fail(3)) SWIG_fail;
39733 }
39734 {
39735 PyThreadState* __tstate = wxPyBeginAllowThreads();
39736 (arg1)->SetRatio(arg2,arg3);
39737
39738 wxPyEndAllowThreads(__tstate);
39739 if (PyErr_Occurred()) SWIG_fail;
39740 }
39741 Py_INCREF(Py_None); resultobj = Py_None;
39742 return resultobj;
39743 fail:
39744 return NULL;
39745 }
39746
39747
39748 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
39749 PyObject *resultobj = NULL;
39750 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39751 wxSize *arg2 = 0 ;
39752 wxSize temp2 ;
39753 PyObject * obj0 = 0 ;
39754 PyObject * obj1 = 0 ;
39755 char *kwnames[] = {
39756 (char *) "self",(char *) "size", NULL
39757 };
39758
39759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
39760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39761 if (SWIG_arg_fail(1)) SWIG_fail;
39762 {
39763 arg2 = &temp2;
39764 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39765 }
39766 {
39767 PyThreadState* __tstate = wxPyBeginAllowThreads();
39768 (arg1)->SetRatio((wxSize const &)*arg2);
39769
39770 wxPyEndAllowThreads(__tstate);
39771 if (PyErr_Occurred()) SWIG_fail;
39772 }
39773 Py_INCREF(Py_None); resultobj = Py_None;
39774 return resultobj;
39775 fail:
39776 return NULL;
39777 }
39778
39779
39780 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39781 PyObject *resultobj = NULL;
39782 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39783 float arg2 ;
39784 PyObject * obj0 = 0 ;
39785 PyObject * obj1 = 0 ;
39786 char *kwnames[] = {
39787 (char *) "self",(char *) "ratio", NULL
39788 };
39789
39790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
39791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39792 if (SWIG_arg_fail(1)) SWIG_fail;
39793 {
39794 arg2 = static_cast<float >(SWIG_As_float(obj1));
39795 if (SWIG_arg_fail(2)) SWIG_fail;
39796 }
39797 {
39798 PyThreadState* __tstate = wxPyBeginAllowThreads();
39799 (arg1)->SetRatio(arg2);
39800
39801 wxPyEndAllowThreads(__tstate);
39802 if (PyErr_Occurred()) SWIG_fail;
39803 }
39804 Py_INCREF(Py_None); resultobj = Py_None;
39805 return resultobj;
39806 fail:
39807 return NULL;
39808 }
39809
39810
39811 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39812 PyObject *resultobj = NULL;
39813 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39814 float result;
39815 PyObject * obj0 = 0 ;
39816 char *kwnames[] = {
39817 (char *) "self", NULL
39818 };
39819
39820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
39821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39822 if (SWIG_arg_fail(1)) SWIG_fail;
39823 {
39824 PyThreadState* __tstate = wxPyBeginAllowThreads();
39825 result = (float)(arg1)->GetRatio();
39826
39827 wxPyEndAllowThreads(__tstate);
39828 if (PyErr_Occurred()) SWIG_fail;
39829 }
39830 {
39831 resultobj = SWIG_From_float(static_cast<float >(result));
39832 }
39833 return resultobj;
39834 fail:
39835 return NULL;
39836 }
39837
39838
39839 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
39840 PyObject *resultobj = NULL;
39841 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39842 wxRect result;
39843 PyObject * obj0 = 0 ;
39844 char *kwnames[] = {
39845 (char *) "self", NULL
39846 };
39847
39848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
39849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39850 if (SWIG_arg_fail(1)) SWIG_fail;
39851 {
39852 PyThreadState* __tstate = wxPyBeginAllowThreads();
39853 result = (arg1)->GetRect();
39854
39855 wxPyEndAllowThreads(__tstate);
39856 if (PyErr_Occurred()) SWIG_fail;
39857 }
39858 {
39859 wxRect * resultptr;
39860 resultptr = new wxRect(static_cast<wxRect & >(result));
39861 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39862 }
39863 return resultobj;
39864 fail:
39865 return NULL;
39866 }
39867
39868
39869 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39870 PyObject *resultobj = NULL;
39871 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39872 bool result;
39873 PyObject * obj0 = 0 ;
39874 char *kwnames[] = {
39875 (char *) "self", NULL
39876 };
39877
39878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39880 if (SWIG_arg_fail(1)) SWIG_fail;
39881 {
39882 PyThreadState* __tstate = wxPyBeginAllowThreads();
39883 result = (bool)(arg1)->IsWindow();
39884
39885 wxPyEndAllowThreads(__tstate);
39886 if (PyErr_Occurred()) SWIG_fail;
39887 }
39888 {
39889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39890 }
39891 return resultobj;
39892 fail:
39893 return NULL;
39894 }
39895
39896
39897 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39898 PyObject *resultobj = NULL;
39899 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39900 bool result;
39901 PyObject * obj0 = 0 ;
39902 char *kwnames[] = {
39903 (char *) "self", NULL
39904 };
39905
39906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39908 if (SWIG_arg_fail(1)) SWIG_fail;
39909 {
39910 PyThreadState* __tstate = wxPyBeginAllowThreads();
39911 result = (bool)(arg1)->IsSizer();
39912
39913 wxPyEndAllowThreads(__tstate);
39914 if (PyErr_Occurred()) SWIG_fail;
39915 }
39916 {
39917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39918 }
39919 return resultobj;
39920 fail:
39921 return NULL;
39922 }
39923
39924
39925 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39926 PyObject *resultobj = NULL;
39927 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39928 bool result;
39929 PyObject * obj0 = 0 ;
39930 char *kwnames[] = {
39931 (char *) "self", NULL
39932 };
39933
39934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39936 if (SWIG_arg_fail(1)) SWIG_fail;
39937 {
39938 PyThreadState* __tstate = wxPyBeginAllowThreads();
39939 result = (bool)(arg1)->IsSpacer();
39940
39941 wxPyEndAllowThreads(__tstate);
39942 if (PyErr_Occurred()) SWIG_fail;
39943 }
39944 {
39945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39946 }
39947 return resultobj;
39948 fail:
39949 return NULL;
39950 }
39951
39952
39953 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39954 PyObject *resultobj = NULL;
39955 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39956 int arg2 ;
39957 PyObject * obj0 = 0 ;
39958 PyObject * obj1 = 0 ;
39959 char *kwnames[] = {
39960 (char *) "self",(char *) "proportion", NULL
39961 };
39962
39963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39965 if (SWIG_arg_fail(1)) SWIG_fail;
39966 {
39967 arg2 = static_cast<int >(SWIG_As_int(obj1));
39968 if (SWIG_arg_fail(2)) SWIG_fail;
39969 }
39970 {
39971 PyThreadState* __tstate = wxPyBeginAllowThreads();
39972 (arg1)->SetProportion(arg2);
39973
39974 wxPyEndAllowThreads(__tstate);
39975 if (PyErr_Occurred()) SWIG_fail;
39976 }
39977 Py_INCREF(Py_None); resultobj = Py_None;
39978 return resultobj;
39979 fail:
39980 return NULL;
39981 }
39982
39983
39984 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39985 PyObject *resultobj = NULL;
39986 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39987 int result;
39988 PyObject * obj0 = 0 ;
39989 char *kwnames[] = {
39990 (char *) "self", NULL
39991 };
39992
39993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39995 if (SWIG_arg_fail(1)) SWIG_fail;
39996 {
39997 PyThreadState* __tstate = wxPyBeginAllowThreads();
39998 result = (int)(arg1)->GetProportion();
39999
40000 wxPyEndAllowThreads(__tstate);
40001 if (PyErr_Occurred()) SWIG_fail;
40002 }
40003 {
40004 resultobj = SWIG_From_int(static_cast<int >(result));
40005 }
40006 return resultobj;
40007 fail:
40008 return NULL;
40009 }
40010
40011
40012 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
40013 PyObject *resultobj = NULL;
40014 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40015 int arg2 ;
40016 PyObject * obj0 = 0 ;
40017 PyObject * obj1 = 0 ;
40018 char *kwnames[] = {
40019 (char *) "self",(char *) "flag", NULL
40020 };
40021
40022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
40023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40024 if (SWIG_arg_fail(1)) SWIG_fail;
40025 {
40026 arg2 = static_cast<int >(SWIG_As_int(obj1));
40027 if (SWIG_arg_fail(2)) SWIG_fail;
40028 }
40029 {
40030 PyThreadState* __tstate = wxPyBeginAllowThreads();
40031 (arg1)->SetFlag(arg2);
40032
40033 wxPyEndAllowThreads(__tstate);
40034 if (PyErr_Occurred()) SWIG_fail;
40035 }
40036 Py_INCREF(Py_None); resultobj = Py_None;
40037 return resultobj;
40038 fail:
40039 return NULL;
40040 }
40041
40042
40043 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
40044 PyObject *resultobj = NULL;
40045 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40046 int result;
40047 PyObject * obj0 = 0 ;
40048 char *kwnames[] = {
40049 (char *) "self", NULL
40050 };
40051
40052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
40053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40054 if (SWIG_arg_fail(1)) SWIG_fail;
40055 {
40056 PyThreadState* __tstate = wxPyBeginAllowThreads();
40057 result = (int)(arg1)->GetFlag();
40058
40059 wxPyEndAllowThreads(__tstate);
40060 if (PyErr_Occurred()) SWIG_fail;
40061 }
40062 {
40063 resultobj = SWIG_From_int(static_cast<int >(result));
40064 }
40065 return resultobj;
40066 fail:
40067 return NULL;
40068 }
40069
40070
40071 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
40072 PyObject *resultobj = NULL;
40073 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40074 int arg2 ;
40075 PyObject * obj0 = 0 ;
40076 PyObject * obj1 = 0 ;
40077 char *kwnames[] = {
40078 (char *) "self",(char *) "border", NULL
40079 };
40080
40081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
40082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40083 if (SWIG_arg_fail(1)) SWIG_fail;
40084 {
40085 arg2 = static_cast<int >(SWIG_As_int(obj1));
40086 if (SWIG_arg_fail(2)) SWIG_fail;
40087 }
40088 {
40089 PyThreadState* __tstate = wxPyBeginAllowThreads();
40090 (arg1)->SetBorder(arg2);
40091
40092 wxPyEndAllowThreads(__tstate);
40093 if (PyErr_Occurred()) SWIG_fail;
40094 }
40095 Py_INCREF(Py_None); resultobj = Py_None;
40096 return resultobj;
40097 fail:
40098 return NULL;
40099 }
40100
40101
40102 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
40103 PyObject *resultobj = NULL;
40104 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40105 int result;
40106 PyObject * obj0 = 0 ;
40107 char *kwnames[] = {
40108 (char *) "self", NULL
40109 };
40110
40111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
40112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40113 if (SWIG_arg_fail(1)) SWIG_fail;
40114 {
40115 PyThreadState* __tstate = wxPyBeginAllowThreads();
40116 result = (int)(arg1)->GetBorder();
40117
40118 wxPyEndAllowThreads(__tstate);
40119 if (PyErr_Occurred()) SWIG_fail;
40120 }
40121 {
40122 resultobj = SWIG_From_int(static_cast<int >(result));
40123 }
40124 return resultobj;
40125 fail:
40126 return NULL;
40127 }
40128
40129
40130 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40131 PyObject *resultobj = NULL;
40132 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40133 wxWindow *result;
40134 PyObject * obj0 = 0 ;
40135 char *kwnames[] = {
40136 (char *) "self", NULL
40137 };
40138
40139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
40140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40141 if (SWIG_arg_fail(1)) SWIG_fail;
40142 {
40143 PyThreadState* __tstate = wxPyBeginAllowThreads();
40144 result = (wxWindow *)(arg1)->GetWindow();
40145
40146 wxPyEndAllowThreads(__tstate);
40147 if (PyErr_Occurred()) SWIG_fail;
40148 }
40149 {
40150 resultobj = wxPyMake_wxObject(result, 0);
40151 }
40152 return resultobj;
40153 fail:
40154 return NULL;
40155 }
40156
40157
40158 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
40159 PyObject *resultobj = NULL;
40160 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40161 wxWindow *arg2 = (wxWindow *) 0 ;
40162 PyObject * obj0 = 0 ;
40163 PyObject * obj1 = 0 ;
40164 char *kwnames[] = {
40165 (char *) "self",(char *) "window", NULL
40166 };
40167
40168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
40169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40170 if (SWIG_arg_fail(1)) SWIG_fail;
40171 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40172 if (SWIG_arg_fail(2)) SWIG_fail;
40173 {
40174 PyThreadState* __tstate = wxPyBeginAllowThreads();
40175 (arg1)->SetWindow(arg2);
40176
40177 wxPyEndAllowThreads(__tstate);
40178 if (PyErr_Occurred()) SWIG_fail;
40179 }
40180 Py_INCREF(Py_None); resultobj = Py_None;
40181 return resultobj;
40182 fail:
40183 return NULL;
40184 }
40185
40186
40187 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40188 PyObject *resultobj = NULL;
40189 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40190 wxSizer *result;
40191 PyObject * obj0 = 0 ;
40192 char *kwnames[] = {
40193 (char *) "self", NULL
40194 };
40195
40196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
40197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40198 if (SWIG_arg_fail(1)) SWIG_fail;
40199 {
40200 PyThreadState* __tstate = wxPyBeginAllowThreads();
40201 result = (wxSizer *)(arg1)->GetSizer();
40202
40203 wxPyEndAllowThreads(__tstate);
40204 if (PyErr_Occurred()) SWIG_fail;
40205 }
40206 {
40207 resultobj = wxPyMake_wxObject(result, (bool)0);
40208 }
40209 return resultobj;
40210 fail:
40211 return NULL;
40212 }
40213
40214
40215 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40216 PyObject *resultobj = NULL;
40217 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40218 wxSizer *arg2 = (wxSizer *) 0 ;
40219 PyObject * obj0 = 0 ;
40220 PyObject * obj1 = 0 ;
40221 char *kwnames[] = {
40222 (char *) "self",(char *) "sizer", NULL
40223 };
40224
40225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
40226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40227 if (SWIG_arg_fail(1)) SWIG_fail;
40228 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40229 if (SWIG_arg_fail(2)) SWIG_fail;
40230 {
40231 PyThreadState* __tstate = wxPyBeginAllowThreads();
40232 (arg1)->SetSizer(arg2);
40233
40234 wxPyEndAllowThreads(__tstate);
40235 if (PyErr_Occurred()) SWIG_fail;
40236 }
40237 Py_INCREF(Py_None); resultobj = Py_None;
40238 return resultobj;
40239 fail:
40240 return NULL;
40241 }
40242
40243
40244 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40245 PyObject *resultobj = NULL;
40246 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40247 wxSize *result;
40248 PyObject * obj0 = 0 ;
40249 char *kwnames[] = {
40250 (char *) "self", NULL
40251 };
40252
40253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
40254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40255 if (SWIG_arg_fail(1)) SWIG_fail;
40256 {
40257 PyThreadState* __tstate = wxPyBeginAllowThreads();
40258 {
40259 wxSize const &_result_ref = (arg1)->GetSpacer();
40260 result = (wxSize *) &_result_ref;
40261 }
40262
40263 wxPyEndAllowThreads(__tstate);
40264 if (PyErr_Occurred()) SWIG_fail;
40265 }
40266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
40267 return resultobj;
40268 fail:
40269 return NULL;
40270 }
40271
40272
40273 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
40274 PyObject *resultobj = NULL;
40275 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40276 wxSize *arg2 = 0 ;
40277 wxSize temp2 ;
40278 PyObject * obj0 = 0 ;
40279 PyObject * obj1 = 0 ;
40280 char *kwnames[] = {
40281 (char *) "self",(char *) "size", NULL
40282 };
40283
40284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
40285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40286 if (SWIG_arg_fail(1)) SWIG_fail;
40287 {
40288 arg2 = &temp2;
40289 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40290 }
40291 {
40292 PyThreadState* __tstate = wxPyBeginAllowThreads();
40293 (arg1)->SetSpacer((wxSize const &)*arg2);
40294
40295 wxPyEndAllowThreads(__tstate);
40296 if (PyErr_Occurred()) SWIG_fail;
40297 }
40298 Py_INCREF(Py_None); resultobj = Py_None;
40299 return resultobj;
40300 fail:
40301 return NULL;
40302 }
40303
40304
40305 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40306 PyObject *resultobj = NULL;
40307 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40308 bool arg2 ;
40309 PyObject * obj0 = 0 ;
40310 PyObject * obj1 = 0 ;
40311 char *kwnames[] = {
40312 (char *) "self",(char *) "show", NULL
40313 };
40314
40315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
40316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40317 if (SWIG_arg_fail(1)) SWIG_fail;
40318 {
40319 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
40320 if (SWIG_arg_fail(2)) SWIG_fail;
40321 }
40322 {
40323 PyThreadState* __tstate = wxPyBeginAllowThreads();
40324 (arg1)->Show(arg2);
40325
40326 wxPyEndAllowThreads(__tstate);
40327 if (PyErr_Occurred()) SWIG_fail;
40328 }
40329 Py_INCREF(Py_None); resultobj = Py_None;
40330 return resultobj;
40331 fail:
40332 return NULL;
40333 }
40334
40335
40336 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40337 PyObject *resultobj = NULL;
40338 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40339 bool result;
40340 PyObject * obj0 = 0 ;
40341 char *kwnames[] = {
40342 (char *) "self", NULL
40343 };
40344
40345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
40346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40347 if (SWIG_arg_fail(1)) SWIG_fail;
40348 {
40349 PyThreadState* __tstate = wxPyBeginAllowThreads();
40350 result = (bool)(arg1)->IsShown();
40351
40352 wxPyEndAllowThreads(__tstate);
40353 if (PyErr_Occurred()) SWIG_fail;
40354 }
40355 {
40356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40357 }
40358 return resultobj;
40359 fail:
40360 return NULL;
40361 }
40362
40363
40364 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40365 PyObject *resultobj = NULL;
40366 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40367 wxPoint result;
40368 PyObject * obj0 = 0 ;
40369 char *kwnames[] = {
40370 (char *) "self", NULL
40371 };
40372
40373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
40374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40375 if (SWIG_arg_fail(1)) SWIG_fail;
40376 {
40377 PyThreadState* __tstate = wxPyBeginAllowThreads();
40378 result = (arg1)->GetPosition();
40379
40380 wxPyEndAllowThreads(__tstate);
40381 if (PyErr_Occurred()) SWIG_fail;
40382 }
40383 {
40384 wxPoint * resultptr;
40385 resultptr = new wxPoint(static_cast<wxPoint & >(result));
40386 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40387 }
40388 return resultobj;
40389 fail:
40390 return NULL;
40391 }
40392
40393
40394 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40395 PyObject *resultobj = NULL;
40396 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40397 PyObject *result;
40398 PyObject * obj0 = 0 ;
40399 char *kwnames[] = {
40400 (char *) "self", NULL
40401 };
40402
40403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
40404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40405 if (SWIG_arg_fail(1)) SWIG_fail;
40406 {
40407 PyThreadState* __tstate = wxPyBeginAllowThreads();
40408 result = (PyObject *)wxSizerItem_GetUserData(arg1);
40409
40410 wxPyEndAllowThreads(__tstate);
40411 if (PyErr_Occurred()) SWIG_fail;
40412 }
40413 resultobj = result;
40414 return resultobj;
40415 fail:
40416 return NULL;
40417 }
40418
40419
40420 static PyObject *_wrap_SizerItem_SetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40421 PyObject *resultobj = NULL;
40422 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40423 PyObject *arg2 = (PyObject *) 0 ;
40424 PyObject * obj0 = 0 ;
40425 PyObject * obj1 = 0 ;
40426 char *kwnames[] = {
40427 (char *) "self",(char *) "userData", NULL
40428 };
40429
40430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) goto fail;
40431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40432 if (SWIG_arg_fail(1)) SWIG_fail;
40433 arg2 = obj1;
40434 {
40435 PyThreadState* __tstate = wxPyBeginAllowThreads();
40436 wxSizerItem_SetUserData(arg1,arg2);
40437
40438 wxPyEndAllowThreads(__tstate);
40439 if (PyErr_Occurred()) SWIG_fail;
40440 }
40441 Py_INCREF(Py_None); resultobj = Py_None;
40442 return resultobj;
40443 fail:
40444 return NULL;
40445 }
40446
40447
40448 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
40449 PyObject *obj;
40450 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40451 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
40452 Py_INCREF(obj);
40453 return Py_BuildValue((char *)"");
40454 }
40455 static PyObject *_wrap_delete_Sizer(PyObject *, PyObject *args, PyObject *kwargs) {
40456 PyObject *resultobj = NULL;
40457 wxSizer *arg1 = (wxSizer *) 0 ;
40458 PyObject * obj0 = 0 ;
40459 char *kwnames[] = {
40460 (char *) "self", NULL
40461 };
40462
40463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Sizer",kwnames,&obj0)) goto fail;
40464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40465 if (SWIG_arg_fail(1)) SWIG_fail;
40466 {
40467 PyThreadState* __tstate = wxPyBeginAllowThreads();
40468 delete arg1;
40469
40470 wxPyEndAllowThreads(__tstate);
40471 if (PyErr_Occurred()) SWIG_fail;
40472 }
40473 Py_INCREF(Py_None); resultobj = Py_None;
40474 return resultobj;
40475 fail:
40476 return NULL;
40477 }
40478
40479
40480 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40481 PyObject *resultobj = NULL;
40482 wxSizer *arg1 = (wxSizer *) 0 ;
40483 PyObject *arg2 = (PyObject *) 0 ;
40484 PyObject * obj0 = 0 ;
40485 PyObject * obj1 = 0 ;
40486 char *kwnames[] = {
40487 (char *) "self",(char *) "_self", NULL
40488 };
40489
40490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
40491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40492 if (SWIG_arg_fail(1)) SWIG_fail;
40493 arg2 = obj1;
40494 {
40495 PyThreadState* __tstate = wxPyBeginAllowThreads();
40496 wxSizer__setOORInfo(arg1,arg2);
40497
40498 wxPyEndAllowThreads(__tstate);
40499 if (PyErr_Occurred()) SWIG_fail;
40500 }
40501 Py_INCREF(Py_None); resultobj = Py_None;
40502 return resultobj;
40503 fail:
40504 return NULL;
40505 }
40506
40507
40508 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
40509 PyObject *resultobj = NULL;
40510 wxSizer *arg1 = (wxSizer *) 0 ;
40511 PyObject *arg2 = (PyObject *) 0 ;
40512 int arg3 = (int) 0 ;
40513 int arg4 = (int) 0 ;
40514 int arg5 = (int) 0 ;
40515 PyObject *arg6 = (PyObject *) NULL ;
40516 wxSizerItem *result;
40517 PyObject * obj0 = 0 ;
40518 PyObject * obj1 = 0 ;
40519 PyObject * obj2 = 0 ;
40520 PyObject * obj3 = 0 ;
40521 PyObject * obj4 = 0 ;
40522 PyObject * obj5 = 0 ;
40523 char *kwnames[] = {
40524 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40525 };
40526
40527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40529 if (SWIG_arg_fail(1)) SWIG_fail;
40530 arg2 = obj1;
40531 if (obj2) {
40532 {
40533 arg3 = static_cast<int >(SWIG_As_int(obj2));
40534 if (SWIG_arg_fail(3)) SWIG_fail;
40535 }
40536 }
40537 if (obj3) {
40538 {
40539 arg4 = static_cast<int >(SWIG_As_int(obj3));
40540 if (SWIG_arg_fail(4)) SWIG_fail;
40541 }
40542 }
40543 if (obj4) {
40544 {
40545 arg5 = static_cast<int >(SWIG_As_int(obj4));
40546 if (SWIG_arg_fail(5)) SWIG_fail;
40547 }
40548 }
40549 if (obj5) {
40550 arg6 = obj5;
40551 }
40552 {
40553 PyThreadState* __tstate = wxPyBeginAllowThreads();
40554 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
40555
40556 wxPyEndAllowThreads(__tstate);
40557 if (PyErr_Occurred()) SWIG_fail;
40558 }
40559 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40560 return resultobj;
40561 fail:
40562 return NULL;
40563 }
40564
40565
40566 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
40567 PyObject *resultobj = NULL;
40568 wxSizer *arg1 = (wxSizer *) 0 ;
40569 int arg2 ;
40570 PyObject *arg3 = (PyObject *) 0 ;
40571 int arg4 = (int) 0 ;
40572 int arg5 = (int) 0 ;
40573 int arg6 = (int) 0 ;
40574 PyObject *arg7 = (PyObject *) NULL ;
40575 wxSizerItem *result;
40576 PyObject * obj0 = 0 ;
40577 PyObject * obj1 = 0 ;
40578 PyObject * obj2 = 0 ;
40579 PyObject * obj3 = 0 ;
40580 PyObject * obj4 = 0 ;
40581 PyObject * obj5 = 0 ;
40582 PyObject * obj6 = 0 ;
40583 char *kwnames[] = {
40584 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40585 };
40586
40587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
40588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40589 if (SWIG_arg_fail(1)) SWIG_fail;
40590 {
40591 arg2 = static_cast<int >(SWIG_As_int(obj1));
40592 if (SWIG_arg_fail(2)) SWIG_fail;
40593 }
40594 arg3 = obj2;
40595 if (obj3) {
40596 {
40597 arg4 = static_cast<int >(SWIG_As_int(obj3));
40598 if (SWIG_arg_fail(4)) SWIG_fail;
40599 }
40600 }
40601 if (obj4) {
40602 {
40603 arg5 = static_cast<int >(SWIG_As_int(obj4));
40604 if (SWIG_arg_fail(5)) SWIG_fail;
40605 }
40606 }
40607 if (obj5) {
40608 {
40609 arg6 = static_cast<int >(SWIG_As_int(obj5));
40610 if (SWIG_arg_fail(6)) SWIG_fail;
40611 }
40612 }
40613 if (obj6) {
40614 arg7 = obj6;
40615 }
40616 {
40617 PyThreadState* __tstate = wxPyBeginAllowThreads();
40618 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
40619
40620 wxPyEndAllowThreads(__tstate);
40621 if (PyErr_Occurred()) SWIG_fail;
40622 }
40623 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40624 return resultobj;
40625 fail:
40626 return NULL;
40627 }
40628
40629
40630 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
40631 PyObject *resultobj = NULL;
40632 wxSizer *arg1 = (wxSizer *) 0 ;
40633 PyObject *arg2 = (PyObject *) 0 ;
40634 int arg3 = (int) 0 ;
40635 int arg4 = (int) 0 ;
40636 int arg5 = (int) 0 ;
40637 PyObject *arg6 = (PyObject *) NULL ;
40638 wxSizerItem *result;
40639 PyObject * obj0 = 0 ;
40640 PyObject * obj1 = 0 ;
40641 PyObject * obj2 = 0 ;
40642 PyObject * obj3 = 0 ;
40643 PyObject * obj4 = 0 ;
40644 PyObject * obj5 = 0 ;
40645 char *kwnames[] = {
40646 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40647 };
40648
40649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40651 if (SWIG_arg_fail(1)) SWIG_fail;
40652 arg2 = obj1;
40653 if (obj2) {
40654 {
40655 arg3 = static_cast<int >(SWIG_As_int(obj2));
40656 if (SWIG_arg_fail(3)) SWIG_fail;
40657 }
40658 }
40659 if (obj3) {
40660 {
40661 arg4 = static_cast<int >(SWIG_As_int(obj3));
40662 if (SWIG_arg_fail(4)) SWIG_fail;
40663 }
40664 }
40665 if (obj4) {
40666 {
40667 arg5 = static_cast<int >(SWIG_As_int(obj4));
40668 if (SWIG_arg_fail(5)) SWIG_fail;
40669 }
40670 }
40671 if (obj5) {
40672 arg6 = obj5;
40673 }
40674 {
40675 PyThreadState* __tstate = wxPyBeginAllowThreads();
40676 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
40677
40678 wxPyEndAllowThreads(__tstate);
40679 if (PyErr_Occurred()) SWIG_fail;
40680 }
40681 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40682 return resultobj;
40683 fail:
40684 return NULL;
40685 }
40686
40687
40688 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
40689 PyObject *resultobj = NULL;
40690 wxSizer *arg1 = (wxSizer *) 0 ;
40691 PyObject *arg2 = (PyObject *) 0 ;
40692 bool result;
40693 PyObject * obj0 = 0 ;
40694 PyObject * obj1 = 0 ;
40695 char *kwnames[] = {
40696 (char *) "self",(char *) "item", NULL
40697 };
40698
40699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
40700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40701 if (SWIG_arg_fail(1)) SWIG_fail;
40702 arg2 = obj1;
40703 {
40704 PyThreadState* __tstate = wxPyBeginAllowThreads();
40705 result = (bool)wxSizer_Remove(arg1,arg2);
40706
40707 wxPyEndAllowThreads(__tstate);
40708 if (PyErr_Occurred()) SWIG_fail;
40709 }
40710 {
40711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40712 }
40713 return resultobj;
40714 fail:
40715 return NULL;
40716 }
40717
40718
40719 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
40720 PyObject *resultobj = NULL;
40721 wxSizer *arg1 = (wxSizer *) 0 ;
40722 PyObject *arg2 = (PyObject *) 0 ;
40723 bool result;
40724 PyObject * obj0 = 0 ;
40725 PyObject * obj1 = 0 ;
40726 char *kwnames[] = {
40727 (char *) "self",(char *) "item", NULL
40728 };
40729
40730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
40731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40732 if (SWIG_arg_fail(1)) SWIG_fail;
40733 arg2 = obj1;
40734 {
40735 PyThreadState* __tstate = wxPyBeginAllowThreads();
40736 result = (bool)wxSizer_Detach(arg1,arg2);
40737
40738 wxPyEndAllowThreads(__tstate);
40739 if (PyErr_Occurred()) SWIG_fail;
40740 }
40741 {
40742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40743 }
40744 return resultobj;
40745 fail:
40746 return NULL;
40747 }
40748
40749
40750 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
40751 PyObject *resultobj = NULL;
40752 wxSizer *arg1 = (wxSizer *) 0 ;
40753 PyObject *arg2 = (PyObject *) 0 ;
40754 wxSizerItem *result;
40755 PyObject * obj0 = 0 ;
40756 PyObject * obj1 = 0 ;
40757 char *kwnames[] = {
40758 (char *) "self",(char *) "item", NULL
40759 };
40760
40761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
40762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40763 if (SWIG_arg_fail(1)) SWIG_fail;
40764 arg2 = obj1;
40765 {
40766 PyThreadState* __tstate = wxPyBeginAllowThreads();
40767 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
40768
40769 wxPyEndAllowThreads(__tstate);
40770 if (PyErr_Occurred()) SWIG_fail;
40771 }
40772 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40773 return resultobj;
40774 fail:
40775 return NULL;
40776 }
40777
40778
40779 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40780 PyObject *resultobj = NULL;
40781 wxSizer *arg1 = (wxSizer *) 0 ;
40782 PyObject *arg2 = (PyObject *) 0 ;
40783 wxSize *arg3 = 0 ;
40784 wxSize temp3 ;
40785 PyObject * obj0 = 0 ;
40786 PyObject * obj1 = 0 ;
40787 PyObject * obj2 = 0 ;
40788 char *kwnames[] = {
40789 (char *) "self",(char *) "item",(char *) "size", NULL
40790 };
40791
40792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
40793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40794 if (SWIG_arg_fail(1)) SWIG_fail;
40795 arg2 = obj1;
40796 {
40797 arg3 = &temp3;
40798 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
40799 }
40800 {
40801 PyThreadState* __tstate = wxPyBeginAllowThreads();
40802 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
40803
40804 wxPyEndAllowThreads(__tstate);
40805 if (PyErr_Occurred()) SWIG_fail;
40806 }
40807 Py_INCREF(Py_None); resultobj = Py_None;
40808 return resultobj;
40809 fail:
40810 return NULL;
40811 }
40812
40813
40814 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
40815 PyObject *resultobj = NULL;
40816 wxSizer *arg1 = (wxSizer *) 0 ;
40817 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40818 wxSizerItem *result;
40819 PyObject * obj0 = 0 ;
40820 PyObject * obj1 = 0 ;
40821 char *kwnames[] = {
40822 (char *) "self",(char *) "item", NULL
40823 };
40824
40825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
40826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40827 if (SWIG_arg_fail(1)) SWIG_fail;
40828 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40829 if (SWIG_arg_fail(2)) SWIG_fail;
40830 {
40831 PyThreadState* __tstate = wxPyBeginAllowThreads();
40832 result = (wxSizerItem *)(arg1)->Add(arg2);
40833
40834 wxPyEndAllowThreads(__tstate);
40835 if (PyErr_Occurred()) SWIG_fail;
40836 }
40837 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40838 return resultobj;
40839 fail:
40840 return NULL;
40841 }
40842
40843
40844 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
40845 PyObject *resultobj = NULL;
40846 wxSizer *arg1 = (wxSizer *) 0 ;
40847 size_t arg2 ;
40848 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
40849 wxSizerItem *result;
40850 PyObject * obj0 = 0 ;
40851 PyObject * obj1 = 0 ;
40852 PyObject * obj2 = 0 ;
40853 char *kwnames[] = {
40854 (char *) "self",(char *) "index",(char *) "item", NULL
40855 };
40856
40857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
40858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40859 if (SWIG_arg_fail(1)) SWIG_fail;
40860 {
40861 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
40862 if (SWIG_arg_fail(2)) SWIG_fail;
40863 }
40864 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40865 if (SWIG_arg_fail(3)) SWIG_fail;
40866 {
40867 PyThreadState* __tstate = wxPyBeginAllowThreads();
40868 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
40869
40870 wxPyEndAllowThreads(__tstate);
40871 if (PyErr_Occurred()) SWIG_fail;
40872 }
40873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40874 return resultobj;
40875 fail:
40876 return NULL;
40877 }
40878
40879
40880 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
40881 PyObject *resultobj = NULL;
40882 wxSizer *arg1 = (wxSizer *) 0 ;
40883 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40884 wxSizerItem *result;
40885 PyObject * obj0 = 0 ;
40886 PyObject * obj1 = 0 ;
40887 char *kwnames[] = {
40888 (char *) "self",(char *) "item", NULL
40889 };
40890
40891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
40892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40893 if (SWIG_arg_fail(1)) SWIG_fail;
40894 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
40895 if (SWIG_arg_fail(2)) SWIG_fail;
40896 {
40897 PyThreadState* __tstate = wxPyBeginAllowThreads();
40898 result = (wxSizerItem *)(arg1)->Prepend(arg2);
40899
40900 wxPyEndAllowThreads(__tstate);
40901 if (PyErr_Occurred()) SWIG_fail;
40902 }
40903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40904 return resultobj;
40905 fail:
40906 return NULL;
40907 }
40908
40909
40910 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
40911 PyObject *resultobj = NULL;
40912 wxSizer *arg1 = (wxSizer *) 0 ;
40913 int arg2 ;
40914 int arg3 ;
40915 int arg4 ;
40916 int arg5 ;
40917 PyObject * obj0 = 0 ;
40918 PyObject * obj1 = 0 ;
40919 PyObject * obj2 = 0 ;
40920 PyObject * obj3 = 0 ;
40921 PyObject * obj4 = 0 ;
40922 char *kwnames[] = {
40923 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40924 };
40925
40926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40928 if (SWIG_arg_fail(1)) SWIG_fail;
40929 {
40930 arg2 = static_cast<int >(SWIG_As_int(obj1));
40931 if (SWIG_arg_fail(2)) SWIG_fail;
40932 }
40933 {
40934 arg3 = static_cast<int >(SWIG_As_int(obj2));
40935 if (SWIG_arg_fail(3)) SWIG_fail;
40936 }
40937 {
40938 arg4 = static_cast<int >(SWIG_As_int(obj3));
40939 if (SWIG_arg_fail(4)) SWIG_fail;
40940 }
40941 {
40942 arg5 = static_cast<int >(SWIG_As_int(obj4));
40943 if (SWIG_arg_fail(5)) SWIG_fail;
40944 }
40945 {
40946 PyThreadState* __tstate = wxPyBeginAllowThreads();
40947 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40948
40949 wxPyEndAllowThreads(__tstate);
40950 if (PyErr_Occurred()) SWIG_fail;
40951 }
40952 Py_INCREF(Py_None); resultobj = Py_None;
40953 return resultobj;
40954 fail:
40955 return NULL;
40956 }
40957
40958
40959 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40960 PyObject *resultobj = NULL;
40961 wxSizer *arg1 = (wxSizer *) 0 ;
40962 wxSize *arg2 = 0 ;
40963 wxSize temp2 ;
40964 PyObject * obj0 = 0 ;
40965 PyObject * obj1 = 0 ;
40966 char *kwnames[] = {
40967 (char *) "self",(char *) "size", NULL
40968 };
40969
40970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40972 if (SWIG_arg_fail(1)) SWIG_fail;
40973 {
40974 arg2 = &temp2;
40975 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40976 }
40977 {
40978 PyThreadState* __tstate = wxPyBeginAllowThreads();
40979 (arg1)->SetMinSize((wxSize const &)*arg2);
40980
40981 wxPyEndAllowThreads(__tstate);
40982 if (PyErr_Occurred()) SWIG_fail;
40983 }
40984 Py_INCREF(Py_None); resultobj = Py_None;
40985 return resultobj;
40986 fail:
40987 return NULL;
40988 }
40989
40990
40991 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40992 PyObject *resultobj = NULL;
40993 wxSizer *arg1 = (wxSizer *) 0 ;
40994 wxSize result;
40995 PyObject * obj0 = 0 ;
40996 char *kwnames[] = {
40997 (char *) "self", NULL
40998 };
40999
41000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
41001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41002 if (SWIG_arg_fail(1)) SWIG_fail;
41003 {
41004 PyThreadState* __tstate = wxPyBeginAllowThreads();
41005 result = (arg1)->GetSize();
41006
41007 wxPyEndAllowThreads(__tstate);
41008 if (PyErr_Occurred()) SWIG_fail;
41009 }
41010 {
41011 wxSize * resultptr;
41012 resultptr = new wxSize(static_cast<wxSize & >(result));
41013 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41014 }
41015 return resultobj;
41016 fail:
41017 return NULL;
41018 }
41019
41020
41021 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41022 PyObject *resultobj = NULL;
41023 wxSizer *arg1 = (wxSizer *) 0 ;
41024 wxPoint result;
41025 PyObject * obj0 = 0 ;
41026 char *kwnames[] = {
41027 (char *) "self", NULL
41028 };
41029
41030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
41031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41032 if (SWIG_arg_fail(1)) SWIG_fail;
41033 {
41034 PyThreadState* __tstate = wxPyBeginAllowThreads();
41035 result = (arg1)->GetPosition();
41036
41037 wxPyEndAllowThreads(__tstate);
41038 if (PyErr_Occurred()) SWIG_fail;
41039 }
41040 {
41041 wxPoint * resultptr;
41042 resultptr = new wxPoint(static_cast<wxPoint & >(result));
41043 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
41044 }
41045 return resultobj;
41046 fail:
41047 return NULL;
41048 }
41049
41050
41051 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
41052 PyObject *resultobj = NULL;
41053 wxSizer *arg1 = (wxSizer *) 0 ;
41054 wxSize result;
41055 PyObject * obj0 = 0 ;
41056 char *kwnames[] = {
41057 (char *) "self", NULL
41058 };
41059
41060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
41061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41062 if (SWIG_arg_fail(1)) SWIG_fail;
41063 {
41064 PyThreadState* __tstate = wxPyBeginAllowThreads();
41065 result = (arg1)->GetMinSize();
41066
41067 wxPyEndAllowThreads(__tstate);
41068 if (PyErr_Occurred()) SWIG_fail;
41069 }
41070 {
41071 wxSize * resultptr;
41072 resultptr = new wxSize(static_cast<wxSize & >(result));
41073 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41074 }
41075 return resultobj;
41076 fail:
41077 return NULL;
41078 }
41079
41080
41081 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
41082 PyObject *resultobj = NULL;
41083 wxSizer *arg1 = (wxSizer *) 0 ;
41084 PyObject * obj0 = 0 ;
41085 char *kwnames[] = {
41086 (char *) "self", NULL
41087 };
41088
41089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
41090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41091 if (SWIG_arg_fail(1)) SWIG_fail;
41092 {
41093 PyThreadState* __tstate = wxPyBeginAllowThreads();
41094 (arg1)->RecalcSizes();
41095
41096 wxPyEndAllowThreads(__tstate);
41097 if (PyErr_Occurred()) SWIG_fail;
41098 }
41099 Py_INCREF(Py_None); resultobj = Py_None;
41100 return resultobj;
41101 fail:
41102 return NULL;
41103 }
41104
41105
41106 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
41107 PyObject *resultobj = NULL;
41108 wxSizer *arg1 = (wxSizer *) 0 ;
41109 wxSize result;
41110 PyObject * obj0 = 0 ;
41111 char *kwnames[] = {
41112 (char *) "self", NULL
41113 };
41114
41115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
41116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41117 if (SWIG_arg_fail(1)) SWIG_fail;
41118 {
41119 PyThreadState* __tstate = wxPyBeginAllowThreads();
41120 result = (arg1)->CalcMin();
41121
41122 wxPyEndAllowThreads(__tstate);
41123 if (PyErr_Occurred()) SWIG_fail;
41124 }
41125 {
41126 wxSize * resultptr;
41127 resultptr = new wxSize(static_cast<wxSize & >(result));
41128 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41129 }
41130 return resultobj;
41131 fail:
41132 return NULL;
41133 }
41134
41135
41136 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
41137 PyObject *resultobj = NULL;
41138 wxSizer *arg1 = (wxSizer *) 0 ;
41139 PyObject * obj0 = 0 ;
41140 char *kwnames[] = {
41141 (char *) "self", NULL
41142 };
41143
41144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
41145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41146 if (SWIG_arg_fail(1)) SWIG_fail;
41147 {
41148 PyThreadState* __tstate = wxPyBeginAllowThreads();
41149 (arg1)->Layout();
41150
41151 wxPyEndAllowThreads(__tstate);
41152 if (PyErr_Occurred()) SWIG_fail;
41153 }
41154 Py_INCREF(Py_None); resultobj = Py_None;
41155 return resultobj;
41156 fail:
41157 return NULL;
41158 }
41159
41160
41161 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
41162 PyObject *resultobj = NULL;
41163 wxSizer *arg1 = (wxSizer *) 0 ;
41164 wxWindow *arg2 = (wxWindow *) 0 ;
41165 wxSize result;
41166 PyObject * obj0 = 0 ;
41167 PyObject * obj1 = 0 ;
41168 char *kwnames[] = {
41169 (char *) "self",(char *) "window", NULL
41170 };
41171
41172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
41173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41174 if (SWIG_arg_fail(1)) SWIG_fail;
41175 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41176 if (SWIG_arg_fail(2)) SWIG_fail;
41177 {
41178 PyThreadState* __tstate = wxPyBeginAllowThreads();
41179 result = (arg1)->Fit(arg2);
41180
41181 wxPyEndAllowThreads(__tstate);
41182 if (PyErr_Occurred()) SWIG_fail;
41183 }
41184 {
41185 wxSize * resultptr;
41186 resultptr = new wxSize(static_cast<wxSize & >(result));
41187 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41188 }
41189 return resultobj;
41190 fail:
41191 return NULL;
41192 }
41193
41194
41195 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
41196 PyObject *resultobj = NULL;
41197 wxSizer *arg1 = (wxSizer *) 0 ;
41198 wxWindow *arg2 = (wxWindow *) 0 ;
41199 PyObject * obj0 = 0 ;
41200 PyObject * obj1 = 0 ;
41201 char *kwnames[] = {
41202 (char *) "self",(char *) "window", NULL
41203 };
41204
41205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
41206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41207 if (SWIG_arg_fail(1)) SWIG_fail;
41208 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41209 if (SWIG_arg_fail(2)) SWIG_fail;
41210 {
41211 PyThreadState* __tstate = wxPyBeginAllowThreads();
41212 (arg1)->FitInside(arg2);
41213
41214 wxPyEndAllowThreads(__tstate);
41215 if (PyErr_Occurred()) SWIG_fail;
41216 }
41217 Py_INCREF(Py_None); resultobj = Py_None;
41218 return resultobj;
41219 fail:
41220 return NULL;
41221 }
41222
41223
41224 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
41225 PyObject *resultobj = NULL;
41226 wxSizer *arg1 = (wxSizer *) 0 ;
41227 wxWindow *arg2 = (wxWindow *) 0 ;
41228 PyObject * obj0 = 0 ;
41229 PyObject * obj1 = 0 ;
41230 char *kwnames[] = {
41231 (char *) "self",(char *) "window", NULL
41232 };
41233
41234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
41235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41236 if (SWIG_arg_fail(1)) SWIG_fail;
41237 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41238 if (SWIG_arg_fail(2)) SWIG_fail;
41239 {
41240 PyThreadState* __tstate = wxPyBeginAllowThreads();
41241 (arg1)->SetSizeHints(arg2);
41242
41243 wxPyEndAllowThreads(__tstate);
41244 if (PyErr_Occurred()) SWIG_fail;
41245 }
41246 Py_INCREF(Py_None); resultobj = Py_None;
41247 return resultobj;
41248 fail:
41249 return NULL;
41250 }
41251
41252
41253 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
41254 PyObject *resultobj = NULL;
41255 wxSizer *arg1 = (wxSizer *) 0 ;
41256 wxWindow *arg2 = (wxWindow *) 0 ;
41257 PyObject * obj0 = 0 ;
41258 PyObject * obj1 = 0 ;
41259 char *kwnames[] = {
41260 (char *) "self",(char *) "window", NULL
41261 };
41262
41263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
41264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41265 if (SWIG_arg_fail(1)) SWIG_fail;
41266 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41267 if (SWIG_arg_fail(2)) SWIG_fail;
41268 {
41269 PyThreadState* __tstate = wxPyBeginAllowThreads();
41270 (arg1)->SetVirtualSizeHints(arg2);
41271
41272 wxPyEndAllowThreads(__tstate);
41273 if (PyErr_Occurred()) SWIG_fail;
41274 }
41275 Py_INCREF(Py_None); resultobj = Py_None;
41276 return resultobj;
41277 fail:
41278 return NULL;
41279 }
41280
41281
41282 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
41283 PyObject *resultobj = NULL;
41284 wxSizer *arg1 = (wxSizer *) 0 ;
41285 bool arg2 = (bool) false ;
41286 PyObject * obj0 = 0 ;
41287 PyObject * obj1 = 0 ;
41288 char *kwnames[] = {
41289 (char *) "self",(char *) "deleteWindows", NULL
41290 };
41291
41292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
41293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41294 if (SWIG_arg_fail(1)) SWIG_fail;
41295 if (obj1) {
41296 {
41297 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
41298 if (SWIG_arg_fail(2)) SWIG_fail;
41299 }
41300 }
41301 {
41302 PyThreadState* __tstate = wxPyBeginAllowThreads();
41303 (arg1)->Clear(arg2);
41304
41305 wxPyEndAllowThreads(__tstate);
41306 if (PyErr_Occurred()) SWIG_fail;
41307 }
41308 Py_INCREF(Py_None); resultobj = Py_None;
41309 return resultobj;
41310 fail:
41311 return NULL;
41312 }
41313
41314
41315 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
41316 PyObject *resultobj = NULL;
41317 wxSizer *arg1 = (wxSizer *) 0 ;
41318 PyObject * obj0 = 0 ;
41319 char *kwnames[] = {
41320 (char *) "self", NULL
41321 };
41322
41323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
41324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41325 if (SWIG_arg_fail(1)) SWIG_fail;
41326 {
41327 PyThreadState* __tstate = wxPyBeginAllowThreads();
41328 (arg1)->DeleteWindows();
41329
41330 wxPyEndAllowThreads(__tstate);
41331 if (PyErr_Occurred()) SWIG_fail;
41332 }
41333 Py_INCREF(Py_None); resultobj = Py_None;
41334 return resultobj;
41335 fail:
41336 return NULL;
41337 }
41338
41339
41340 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
41341 PyObject *resultobj = NULL;
41342 wxSizer *arg1 = (wxSizer *) 0 ;
41343 PyObject *result;
41344 PyObject * obj0 = 0 ;
41345 char *kwnames[] = {
41346 (char *) "self", NULL
41347 };
41348
41349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
41350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41351 if (SWIG_arg_fail(1)) SWIG_fail;
41352 {
41353 PyThreadState* __tstate = wxPyBeginAllowThreads();
41354 result = (PyObject *)wxSizer_GetChildren(arg1);
41355
41356 wxPyEndAllowThreads(__tstate);
41357 if (PyErr_Occurred()) SWIG_fail;
41358 }
41359 resultobj = result;
41360 return resultobj;
41361 fail:
41362 return NULL;
41363 }
41364
41365
41366 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
41367 PyObject *resultobj = NULL;
41368 wxSizer *arg1 = (wxSizer *) 0 ;
41369 PyObject *arg2 = (PyObject *) 0 ;
41370 bool arg3 = (bool) true ;
41371 bool arg4 = (bool) false ;
41372 bool result;
41373 PyObject * obj0 = 0 ;
41374 PyObject * obj1 = 0 ;
41375 PyObject * obj2 = 0 ;
41376 PyObject * obj3 = 0 ;
41377 char *kwnames[] = {
41378 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
41379 };
41380
41381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41383 if (SWIG_arg_fail(1)) SWIG_fail;
41384 arg2 = obj1;
41385 if (obj2) {
41386 {
41387 arg3 = static_cast<bool >(SWIG_As_bool(obj2));
41388 if (SWIG_arg_fail(3)) SWIG_fail;
41389 }
41390 }
41391 if (obj3) {
41392 {
41393 arg4 = static_cast<bool >(SWIG_As_bool(obj3));
41394 if (SWIG_arg_fail(4)) SWIG_fail;
41395 }
41396 }
41397 {
41398 PyThreadState* __tstate = wxPyBeginAllowThreads();
41399 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
41400
41401 wxPyEndAllowThreads(__tstate);
41402 if (PyErr_Occurred()) SWIG_fail;
41403 }
41404 {
41405 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41406 }
41407 return resultobj;
41408 fail:
41409 return NULL;
41410 }
41411
41412
41413 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
41414 PyObject *resultobj = NULL;
41415 wxSizer *arg1 = (wxSizer *) 0 ;
41416 PyObject *arg2 = (PyObject *) 0 ;
41417 bool result;
41418 PyObject * obj0 = 0 ;
41419 PyObject * obj1 = 0 ;
41420 char *kwnames[] = {
41421 (char *) "self",(char *) "item", NULL
41422 };
41423
41424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
41425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41426 if (SWIG_arg_fail(1)) SWIG_fail;
41427 arg2 = obj1;
41428 {
41429 PyThreadState* __tstate = wxPyBeginAllowThreads();
41430 result = (bool)wxSizer_IsShown(arg1,arg2);
41431
41432 wxPyEndAllowThreads(__tstate);
41433 if (PyErr_Occurred()) SWIG_fail;
41434 }
41435 {
41436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41437 }
41438 return resultobj;
41439 fail:
41440 return NULL;
41441 }
41442
41443
41444 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
41445 PyObject *resultobj = NULL;
41446 wxSizer *arg1 = (wxSizer *) 0 ;
41447 bool arg2 ;
41448 PyObject * obj0 = 0 ;
41449 PyObject * obj1 = 0 ;
41450 char *kwnames[] = {
41451 (char *) "self",(char *) "show", NULL
41452 };
41453
41454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
41455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41456 if (SWIG_arg_fail(1)) SWIG_fail;
41457 {
41458 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
41459 if (SWIG_arg_fail(2)) SWIG_fail;
41460 }
41461 {
41462 PyThreadState* __tstate = wxPyBeginAllowThreads();
41463 (arg1)->ShowItems(arg2);
41464
41465 wxPyEndAllowThreads(__tstate);
41466 if (PyErr_Occurred()) SWIG_fail;
41467 }
41468 Py_INCREF(Py_None); resultobj = Py_None;
41469 return resultobj;
41470 fail:
41471 return NULL;
41472 }
41473
41474
41475 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
41476 PyObject *obj;
41477 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41478 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
41479 Py_INCREF(obj);
41480 return Py_BuildValue((char *)"");
41481 }
41482 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
41483 PyObject *resultobj = NULL;
41484 wxPySizer *result;
41485 char *kwnames[] = {
41486 NULL
41487 };
41488
41489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
41490 {
41491 PyThreadState* __tstate = wxPyBeginAllowThreads();
41492 result = (wxPySizer *)new wxPySizer();
41493
41494 wxPyEndAllowThreads(__tstate);
41495 if (PyErr_Occurred()) SWIG_fail;
41496 }
41497 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
41498 return resultobj;
41499 fail:
41500 return NULL;
41501 }
41502
41503
41504 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
41505 PyObject *resultobj = NULL;
41506 wxPySizer *arg1 = (wxPySizer *) 0 ;
41507 PyObject *arg2 = (PyObject *) 0 ;
41508 PyObject *arg3 = (PyObject *) 0 ;
41509 PyObject * obj0 = 0 ;
41510 PyObject * obj1 = 0 ;
41511 PyObject * obj2 = 0 ;
41512 char *kwnames[] = {
41513 (char *) "self",(char *) "self",(char *) "_class", NULL
41514 };
41515
41516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
41517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
41518 if (SWIG_arg_fail(1)) SWIG_fail;
41519 arg2 = obj1;
41520 arg3 = obj2;
41521 {
41522 PyThreadState* __tstate = wxPyBeginAllowThreads();
41523 (arg1)->_setCallbackInfo(arg2,arg3);
41524
41525 wxPyEndAllowThreads(__tstate);
41526 if (PyErr_Occurred()) SWIG_fail;
41527 }
41528 Py_INCREF(Py_None); resultobj = Py_None;
41529 return resultobj;
41530 fail:
41531 return NULL;
41532 }
41533
41534
41535 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
41536 PyObject *obj;
41537 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41538 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
41539 Py_INCREF(obj);
41540 return Py_BuildValue((char *)"");
41541 }
41542 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41543 PyObject *resultobj = NULL;
41544 int arg1 = (int) wxHORIZONTAL ;
41545 wxBoxSizer *result;
41546 PyObject * obj0 = 0 ;
41547 char *kwnames[] = {
41548 (char *) "orient", NULL
41549 };
41550
41551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
41552 if (obj0) {
41553 {
41554 arg1 = static_cast<int >(SWIG_As_int(obj0));
41555 if (SWIG_arg_fail(1)) SWIG_fail;
41556 }
41557 }
41558 {
41559 PyThreadState* __tstate = wxPyBeginAllowThreads();
41560 result = (wxBoxSizer *)new wxBoxSizer(arg1);
41561
41562 wxPyEndAllowThreads(__tstate);
41563 if (PyErr_Occurred()) SWIG_fail;
41564 }
41565 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
41566 return resultobj;
41567 fail:
41568 return NULL;
41569 }
41570
41571
41572 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41573 PyObject *resultobj = NULL;
41574 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41575 int result;
41576 PyObject * obj0 = 0 ;
41577 char *kwnames[] = {
41578 (char *) "self", NULL
41579 };
41580
41581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
41582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41583 if (SWIG_arg_fail(1)) SWIG_fail;
41584 {
41585 PyThreadState* __tstate = wxPyBeginAllowThreads();
41586 result = (int)(arg1)->GetOrientation();
41587
41588 wxPyEndAllowThreads(__tstate);
41589 if (PyErr_Occurred()) SWIG_fail;
41590 }
41591 {
41592 resultobj = SWIG_From_int(static_cast<int >(result));
41593 }
41594 return resultobj;
41595 fail:
41596 return NULL;
41597 }
41598
41599
41600 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41601 PyObject *resultobj = NULL;
41602 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41603 int arg2 ;
41604 PyObject * obj0 = 0 ;
41605 PyObject * obj1 = 0 ;
41606 char *kwnames[] = {
41607 (char *) "self",(char *) "orient", NULL
41608 };
41609
41610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
41611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41612 if (SWIG_arg_fail(1)) SWIG_fail;
41613 {
41614 arg2 = static_cast<int >(SWIG_As_int(obj1));
41615 if (SWIG_arg_fail(2)) SWIG_fail;
41616 }
41617 {
41618 PyThreadState* __tstate = wxPyBeginAllowThreads();
41619 (arg1)->SetOrientation(arg2);
41620
41621 wxPyEndAllowThreads(__tstate);
41622 if (PyErr_Occurred()) SWIG_fail;
41623 }
41624 Py_INCREF(Py_None); resultobj = Py_None;
41625 return resultobj;
41626 fail:
41627 return NULL;
41628 }
41629
41630
41631 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
41632 PyObject *obj;
41633 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41634 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
41635 Py_INCREF(obj);
41636 return Py_BuildValue((char *)"");
41637 }
41638 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41639 PyObject *resultobj = NULL;
41640 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
41641 int arg2 = (int) wxHORIZONTAL ;
41642 wxStaticBoxSizer *result;
41643 PyObject * obj0 = 0 ;
41644 PyObject * obj1 = 0 ;
41645 char *kwnames[] = {
41646 (char *) "box",(char *) "orient", NULL
41647 };
41648
41649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
41650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
41651 if (SWIG_arg_fail(1)) SWIG_fail;
41652 if (obj1) {
41653 {
41654 arg2 = static_cast<int >(SWIG_As_int(obj1));
41655 if (SWIG_arg_fail(2)) SWIG_fail;
41656 }
41657 }
41658 {
41659 PyThreadState* __tstate = wxPyBeginAllowThreads();
41660 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
41661
41662 wxPyEndAllowThreads(__tstate);
41663 if (PyErr_Occurred()) SWIG_fail;
41664 }
41665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
41666 return resultobj;
41667 fail:
41668 return NULL;
41669 }
41670
41671
41672 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
41673 PyObject *resultobj = NULL;
41674 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
41675 wxStaticBox *result;
41676 PyObject * obj0 = 0 ;
41677 char *kwnames[] = {
41678 (char *) "self", NULL
41679 };
41680
41681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
41682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41683 if (SWIG_arg_fail(1)) SWIG_fail;
41684 {
41685 PyThreadState* __tstate = wxPyBeginAllowThreads();
41686 result = (wxStaticBox *)(arg1)->GetStaticBox();
41687
41688 wxPyEndAllowThreads(__tstate);
41689 if (PyErr_Occurred()) SWIG_fail;
41690 }
41691 {
41692 resultobj = wxPyMake_wxObject(result, (bool)0);
41693 }
41694 return resultobj;
41695 fail:
41696 return NULL;
41697 }
41698
41699
41700 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
41701 PyObject *obj;
41702 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41703 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
41704 Py_INCREF(obj);
41705 return Py_BuildValue((char *)"");
41706 }
41707 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41708 PyObject *resultobj = NULL;
41709 int arg1 = (int) 1 ;
41710 int arg2 = (int) 0 ;
41711 int arg3 = (int) 0 ;
41712 int arg4 = (int) 0 ;
41713 wxGridSizer *result;
41714 PyObject * obj0 = 0 ;
41715 PyObject * obj1 = 0 ;
41716 PyObject * obj2 = 0 ;
41717 PyObject * obj3 = 0 ;
41718 char *kwnames[] = {
41719 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41720 };
41721
41722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41723 if (obj0) {
41724 {
41725 arg1 = static_cast<int >(SWIG_As_int(obj0));
41726 if (SWIG_arg_fail(1)) SWIG_fail;
41727 }
41728 }
41729 if (obj1) {
41730 {
41731 arg2 = static_cast<int >(SWIG_As_int(obj1));
41732 if (SWIG_arg_fail(2)) SWIG_fail;
41733 }
41734 }
41735 if (obj2) {
41736 {
41737 arg3 = static_cast<int >(SWIG_As_int(obj2));
41738 if (SWIG_arg_fail(3)) SWIG_fail;
41739 }
41740 }
41741 if (obj3) {
41742 {
41743 arg4 = static_cast<int >(SWIG_As_int(obj3));
41744 if (SWIG_arg_fail(4)) SWIG_fail;
41745 }
41746 }
41747 {
41748 PyThreadState* __tstate = wxPyBeginAllowThreads();
41749 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
41750
41751 wxPyEndAllowThreads(__tstate);
41752 if (PyErr_Occurred()) SWIG_fail;
41753 }
41754 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
41755 return resultobj;
41756 fail:
41757 return NULL;
41758 }
41759
41760
41761 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41762 PyObject *resultobj = NULL;
41763 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41764 int arg2 ;
41765 PyObject * obj0 = 0 ;
41766 PyObject * obj1 = 0 ;
41767 char *kwnames[] = {
41768 (char *) "self",(char *) "cols", NULL
41769 };
41770
41771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
41772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41773 if (SWIG_arg_fail(1)) SWIG_fail;
41774 {
41775 arg2 = static_cast<int >(SWIG_As_int(obj1));
41776 if (SWIG_arg_fail(2)) SWIG_fail;
41777 }
41778 {
41779 PyThreadState* __tstate = wxPyBeginAllowThreads();
41780 (arg1)->SetCols(arg2);
41781
41782 wxPyEndAllowThreads(__tstate);
41783 if (PyErr_Occurred()) SWIG_fail;
41784 }
41785 Py_INCREF(Py_None); resultobj = Py_None;
41786 return resultobj;
41787 fail:
41788 return NULL;
41789 }
41790
41791
41792 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41793 PyObject *resultobj = NULL;
41794 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41795 int arg2 ;
41796 PyObject * obj0 = 0 ;
41797 PyObject * obj1 = 0 ;
41798 char *kwnames[] = {
41799 (char *) "self",(char *) "rows", NULL
41800 };
41801
41802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
41803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41804 if (SWIG_arg_fail(1)) SWIG_fail;
41805 {
41806 arg2 = static_cast<int >(SWIG_As_int(obj1));
41807 if (SWIG_arg_fail(2)) SWIG_fail;
41808 }
41809 {
41810 PyThreadState* __tstate = wxPyBeginAllowThreads();
41811 (arg1)->SetRows(arg2);
41812
41813 wxPyEndAllowThreads(__tstate);
41814 if (PyErr_Occurred()) SWIG_fail;
41815 }
41816 Py_INCREF(Py_None); resultobj = Py_None;
41817 return resultobj;
41818 fail:
41819 return NULL;
41820 }
41821
41822
41823 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41824 PyObject *resultobj = NULL;
41825 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41826 int arg2 ;
41827 PyObject * obj0 = 0 ;
41828 PyObject * obj1 = 0 ;
41829 char *kwnames[] = {
41830 (char *) "self",(char *) "gap", NULL
41831 };
41832
41833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
41834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41835 if (SWIG_arg_fail(1)) SWIG_fail;
41836 {
41837 arg2 = static_cast<int >(SWIG_As_int(obj1));
41838 if (SWIG_arg_fail(2)) SWIG_fail;
41839 }
41840 {
41841 PyThreadState* __tstate = wxPyBeginAllowThreads();
41842 (arg1)->SetVGap(arg2);
41843
41844 wxPyEndAllowThreads(__tstate);
41845 if (PyErr_Occurred()) SWIG_fail;
41846 }
41847 Py_INCREF(Py_None); resultobj = Py_None;
41848 return resultobj;
41849 fail:
41850 return NULL;
41851 }
41852
41853
41854 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41855 PyObject *resultobj = NULL;
41856 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41857 int arg2 ;
41858 PyObject * obj0 = 0 ;
41859 PyObject * obj1 = 0 ;
41860 char *kwnames[] = {
41861 (char *) "self",(char *) "gap", NULL
41862 };
41863
41864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
41865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41866 if (SWIG_arg_fail(1)) SWIG_fail;
41867 {
41868 arg2 = static_cast<int >(SWIG_As_int(obj1));
41869 if (SWIG_arg_fail(2)) SWIG_fail;
41870 }
41871 {
41872 PyThreadState* __tstate = wxPyBeginAllowThreads();
41873 (arg1)->SetHGap(arg2);
41874
41875 wxPyEndAllowThreads(__tstate);
41876 if (PyErr_Occurred()) SWIG_fail;
41877 }
41878 Py_INCREF(Py_None); resultobj = Py_None;
41879 return resultobj;
41880 fail:
41881 return NULL;
41882 }
41883
41884
41885 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41886 PyObject *resultobj = NULL;
41887 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41888 int result;
41889 PyObject * obj0 = 0 ;
41890 char *kwnames[] = {
41891 (char *) "self", NULL
41892 };
41893
41894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
41895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41896 if (SWIG_arg_fail(1)) SWIG_fail;
41897 {
41898 PyThreadState* __tstate = wxPyBeginAllowThreads();
41899 result = (int)(arg1)->GetCols();
41900
41901 wxPyEndAllowThreads(__tstate);
41902 if (PyErr_Occurred()) SWIG_fail;
41903 }
41904 {
41905 resultobj = SWIG_From_int(static_cast<int >(result));
41906 }
41907 return resultobj;
41908 fail:
41909 return NULL;
41910 }
41911
41912
41913 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41914 PyObject *resultobj = NULL;
41915 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41916 int result;
41917 PyObject * obj0 = 0 ;
41918 char *kwnames[] = {
41919 (char *) "self", NULL
41920 };
41921
41922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41924 if (SWIG_arg_fail(1)) SWIG_fail;
41925 {
41926 PyThreadState* __tstate = wxPyBeginAllowThreads();
41927 result = (int)(arg1)->GetRows();
41928
41929 wxPyEndAllowThreads(__tstate);
41930 if (PyErr_Occurred()) SWIG_fail;
41931 }
41932 {
41933 resultobj = SWIG_From_int(static_cast<int >(result));
41934 }
41935 return resultobj;
41936 fail:
41937 return NULL;
41938 }
41939
41940
41941 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41942 PyObject *resultobj = NULL;
41943 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41944 int result;
41945 PyObject * obj0 = 0 ;
41946 char *kwnames[] = {
41947 (char *) "self", NULL
41948 };
41949
41950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41952 if (SWIG_arg_fail(1)) SWIG_fail;
41953 {
41954 PyThreadState* __tstate = wxPyBeginAllowThreads();
41955 result = (int)(arg1)->GetVGap();
41956
41957 wxPyEndAllowThreads(__tstate);
41958 if (PyErr_Occurred()) SWIG_fail;
41959 }
41960 {
41961 resultobj = SWIG_From_int(static_cast<int >(result));
41962 }
41963 return resultobj;
41964 fail:
41965 return NULL;
41966 }
41967
41968
41969 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41970 PyObject *resultobj = NULL;
41971 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41972 int result;
41973 PyObject * obj0 = 0 ;
41974 char *kwnames[] = {
41975 (char *) "self", NULL
41976 };
41977
41978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41980 if (SWIG_arg_fail(1)) SWIG_fail;
41981 {
41982 PyThreadState* __tstate = wxPyBeginAllowThreads();
41983 result = (int)(arg1)->GetHGap();
41984
41985 wxPyEndAllowThreads(__tstate);
41986 if (PyErr_Occurred()) SWIG_fail;
41987 }
41988 {
41989 resultobj = SWIG_From_int(static_cast<int >(result));
41990 }
41991 return resultobj;
41992 fail:
41993 return NULL;
41994 }
41995
41996
41997 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41998 PyObject *obj;
41999 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42000 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
42001 Py_INCREF(obj);
42002 return Py_BuildValue((char *)"");
42003 }
42004 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42005 PyObject *resultobj = NULL;
42006 int arg1 = (int) 1 ;
42007 int arg2 = (int) 0 ;
42008 int arg3 = (int) 0 ;
42009 int arg4 = (int) 0 ;
42010 wxFlexGridSizer *result;
42011 PyObject * obj0 = 0 ;
42012 PyObject * obj1 = 0 ;
42013 PyObject * obj2 = 0 ;
42014 PyObject * obj3 = 0 ;
42015 char *kwnames[] = {
42016 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
42017 };
42018
42019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42020 if (obj0) {
42021 {
42022 arg1 = static_cast<int >(SWIG_As_int(obj0));
42023 if (SWIG_arg_fail(1)) SWIG_fail;
42024 }
42025 }
42026 if (obj1) {
42027 {
42028 arg2 = static_cast<int >(SWIG_As_int(obj1));
42029 if (SWIG_arg_fail(2)) SWIG_fail;
42030 }
42031 }
42032 if (obj2) {
42033 {
42034 arg3 = static_cast<int >(SWIG_As_int(obj2));
42035 if (SWIG_arg_fail(3)) SWIG_fail;
42036 }
42037 }
42038 if (obj3) {
42039 {
42040 arg4 = static_cast<int >(SWIG_As_int(obj3));
42041 if (SWIG_arg_fail(4)) SWIG_fail;
42042 }
42043 }
42044 {
42045 PyThreadState* __tstate = wxPyBeginAllowThreads();
42046 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
42047
42048 wxPyEndAllowThreads(__tstate);
42049 if (PyErr_Occurred()) SWIG_fail;
42050 }
42051 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
42052 return resultobj;
42053 fail:
42054 return NULL;
42055 }
42056
42057
42058 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
42059 PyObject *resultobj = NULL;
42060 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42061 size_t arg2 ;
42062 int arg3 = (int) 0 ;
42063 PyObject * obj0 = 0 ;
42064 PyObject * obj1 = 0 ;
42065 PyObject * obj2 = 0 ;
42066 char *kwnames[] = {
42067 (char *) "self",(char *) "idx",(char *) "proportion", NULL
42068 };
42069
42070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
42071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42072 if (SWIG_arg_fail(1)) SWIG_fail;
42073 {
42074 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42075 if (SWIG_arg_fail(2)) SWIG_fail;
42076 }
42077 if (obj2) {
42078 {
42079 arg3 = static_cast<int >(SWIG_As_int(obj2));
42080 if (SWIG_arg_fail(3)) SWIG_fail;
42081 }
42082 }
42083 {
42084 PyThreadState* __tstate = wxPyBeginAllowThreads();
42085 (arg1)->AddGrowableRow(arg2,arg3);
42086
42087 wxPyEndAllowThreads(__tstate);
42088 if (PyErr_Occurred()) SWIG_fail;
42089 }
42090 Py_INCREF(Py_None); resultobj = Py_None;
42091 return resultobj;
42092 fail:
42093 return NULL;
42094 }
42095
42096
42097 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
42098 PyObject *resultobj = NULL;
42099 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42100 size_t arg2 ;
42101 PyObject * obj0 = 0 ;
42102 PyObject * obj1 = 0 ;
42103 char *kwnames[] = {
42104 (char *) "self",(char *) "idx", NULL
42105 };
42106
42107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
42108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42109 if (SWIG_arg_fail(1)) SWIG_fail;
42110 {
42111 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42112 if (SWIG_arg_fail(2)) SWIG_fail;
42113 }
42114 {
42115 PyThreadState* __tstate = wxPyBeginAllowThreads();
42116 (arg1)->RemoveGrowableRow(arg2);
42117
42118 wxPyEndAllowThreads(__tstate);
42119 if (PyErr_Occurred()) SWIG_fail;
42120 }
42121 Py_INCREF(Py_None); resultobj = Py_None;
42122 return resultobj;
42123 fail:
42124 return NULL;
42125 }
42126
42127
42128 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
42129 PyObject *resultobj = NULL;
42130 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42131 size_t arg2 ;
42132 int arg3 = (int) 0 ;
42133 PyObject * obj0 = 0 ;
42134 PyObject * obj1 = 0 ;
42135 PyObject * obj2 = 0 ;
42136 char *kwnames[] = {
42137 (char *) "self",(char *) "idx",(char *) "proportion", NULL
42138 };
42139
42140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
42141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42142 if (SWIG_arg_fail(1)) SWIG_fail;
42143 {
42144 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42145 if (SWIG_arg_fail(2)) SWIG_fail;
42146 }
42147 if (obj2) {
42148 {
42149 arg3 = static_cast<int >(SWIG_As_int(obj2));
42150 if (SWIG_arg_fail(3)) SWIG_fail;
42151 }
42152 }
42153 {
42154 PyThreadState* __tstate = wxPyBeginAllowThreads();
42155 (arg1)->AddGrowableCol(arg2,arg3);
42156
42157 wxPyEndAllowThreads(__tstate);
42158 if (PyErr_Occurred()) SWIG_fail;
42159 }
42160 Py_INCREF(Py_None); resultobj = Py_None;
42161 return resultobj;
42162 fail:
42163 return NULL;
42164 }
42165
42166
42167 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
42168 PyObject *resultobj = NULL;
42169 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42170 size_t arg2 ;
42171 PyObject * obj0 = 0 ;
42172 PyObject * obj1 = 0 ;
42173 char *kwnames[] = {
42174 (char *) "self",(char *) "idx", NULL
42175 };
42176
42177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
42178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42179 if (SWIG_arg_fail(1)) SWIG_fail;
42180 {
42181 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
42182 if (SWIG_arg_fail(2)) SWIG_fail;
42183 }
42184 {
42185 PyThreadState* __tstate = wxPyBeginAllowThreads();
42186 (arg1)->RemoveGrowableCol(arg2);
42187
42188 wxPyEndAllowThreads(__tstate);
42189 if (PyErr_Occurred()) SWIG_fail;
42190 }
42191 Py_INCREF(Py_None); resultobj = Py_None;
42192 return resultobj;
42193 fail:
42194 return NULL;
42195 }
42196
42197
42198 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
42199 PyObject *resultobj = NULL;
42200 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42201 int arg2 ;
42202 PyObject * obj0 = 0 ;
42203 PyObject * obj1 = 0 ;
42204 char *kwnames[] = {
42205 (char *) "self",(char *) "direction", NULL
42206 };
42207
42208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
42209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42210 if (SWIG_arg_fail(1)) SWIG_fail;
42211 {
42212 arg2 = static_cast<int >(SWIG_As_int(obj1));
42213 if (SWIG_arg_fail(2)) SWIG_fail;
42214 }
42215 {
42216 PyThreadState* __tstate = wxPyBeginAllowThreads();
42217 (arg1)->SetFlexibleDirection(arg2);
42218
42219 wxPyEndAllowThreads(__tstate);
42220 if (PyErr_Occurred()) SWIG_fail;
42221 }
42222 Py_INCREF(Py_None); resultobj = Py_None;
42223 return resultobj;
42224 fail:
42225 return NULL;
42226 }
42227
42228
42229 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
42230 PyObject *resultobj = NULL;
42231 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42232 int result;
42233 PyObject * obj0 = 0 ;
42234 char *kwnames[] = {
42235 (char *) "self", NULL
42236 };
42237
42238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
42239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42240 if (SWIG_arg_fail(1)) SWIG_fail;
42241 {
42242 PyThreadState* __tstate = wxPyBeginAllowThreads();
42243 result = (int)(arg1)->GetFlexibleDirection();
42244
42245 wxPyEndAllowThreads(__tstate);
42246 if (PyErr_Occurred()) SWIG_fail;
42247 }
42248 {
42249 resultobj = SWIG_From_int(static_cast<int >(result));
42250 }
42251 return resultobj;
42252 fail:
42253 return NULL;
42254 }
42255
42256
42257 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
42258 PyObject *resultobj = NULL;
42259 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42260 wxFlexSizerGrowMode arg2 ;
42261 PyObject * obj0 = 0 ;
42262 PyObject * obj1 = 0 ;
42263 char *kwnames[] = {
42264 (char *) "self",(char *) "mode", NULL
42265 };
42266
42267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
42268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42269 if (SWIG_arg_fail(1)) SWIG_fail;
42270 {
42271 arg2 = static_cast<wxFlexSizerGrowMode >(SWIG_As_int(obj1));
42272 if (SWIG_arg_fail(2)) SWIG_fail;
42273 }
42274 {
42275 PyThreadState* __tstate = wxPyBeginAllowThreads();
42276 (arg1)->SetNonFlexibleGrowMode(arg2);
42277
42278 wxPyEndAllowThreads(__tstate);
42279 if (PyErr_Occurred()) SWIG_fail;
42280 }
42281 Py_INCREF(Py_None); resultobj = Py_None;
42282 return resultobj;
42283 fail:
42284 return NULL;
42285 }
42286
42287
42288 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
42289 PyObject *resultobj = NULL;
42290 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42291 wxFlexSizerGrowMode result;
42292 PyObject * obj0 = 0 ;
42293 char *kwnames[] = {
42294 (char *) "self", NULL
42295 };
42296
42297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
42298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42299 if (SWIG_arg_fail(1)) SWIG_fail;
42300 {
42301 PyThreadState* __tstate = wxPyBeginAllowThreads();
42302 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
42303
42304 wxPyEndAllowThreads(__tstate);
42305 if (PyErr_Occurred()) SWIG_fail;
42306 }
42307 resultobj = SWIG_From_int((result));
42308 return resultobj;
42309 fail:
42310 return NULL;
42311 }
42312
42313
42314 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
42315 PyObject *resultobj = NULL;
42316 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42317 wxArrayInt *result;
42318 PyObject * obj0 = 0 ;
42319 char *kwnames[] = {
42320 (char *) "self", NULL
42321 };
42322
42323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
42324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42325 if (SWIG_arg_fail(1)) SWIG_fail;
42326 {
42327 PyThreadState* __tstate = wxPyBeginAllowThreads();
42328 {
42329 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
42330 result = (wxArrayInt *) &_result_ref;
42331 }
42332
42333 wxPyEndAllowThreads(__tstate);
42334 if (PyErr_Occurred()) SWIG_fail;
42335 }
42336 {
42337 resultobj = PyList_New(0);
42338 size_t idx;
42339 for (idx = 0; idx < result->GetCount(); idx += 1) {
42340 PyObject* val = PyInt_FromLong( result->Item(idx) );
42341 PyList_Append(resultobj, val);
42342 Py_DECREF(val);
42343 }
42344 }
42345 return resultobj;
42346 fail:
42347 return NULL;
42348 }
42349
42350
42351 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
42352 PyObject *resultobj = NULL;
42353 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
42354 wxArrayInt *result;
42355 PyObject * obj0 = 0 ;
42356 char *kwnames[] = {
42357 (char *) "self", NULL
42358 };
42359
42360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
42361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
42362 if (SWIG_arg_fail(1)) SWIG_fail;
42363 {
42364 PyThreadState* __tstate = wxPyBeginAllowThreads();
42365 {
42366 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
42367 result = (wxArrayInt *) &_result_ref;
42368 }
42369
42370 wxPyEndAllowThreads(__tstate);
42371 if (PyErr_Occurred()) SWIG_fail;
42372 }
42373 {
42374 resultobj = PyList_New(0);
42375 size_t idx;
42376 for (idx = 0; idx < result->GetCount(); idx += 1) {
42377 PyObject* val = PyInt_FromLong( result->Item(idx) );
42378 PyList_Append(resultobj, val);
42379 Py_DECREF(val);
42380 }
42381 }
42382 return resultobj;
42383 fail:
42384 return NULL;
42385 }
42386
42387
42388 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
42389 PyObject *obj;
42390 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42391 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
42392 Py_INCREF(obj);
42393 return Py_BuildValue((char *)"");
42394 }
42395 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42396 PyObject *resultobj = NULL;
42397 wxStdDialogButtonSizer *result;
42398 char *kwnames[] = {
42399 NULL
42400 };
42401
42402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
42403 {
42404 PyThreadState* __tstate = wxPyBeginAllowThreads();
42405 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
42406
42407 wxPyEndAllowThreads(__tstate);
42408 if (PyErr_Occurred()) SWIG_fail;
42409 }
42410 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
42411 return resultobj;
42412 fail:
42413 return NULL;
42414 }
42415
42416
42417 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
42418 PyObject *resultobj = NULL;
42419 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42420 wxButton *arg2 = (wxButton *) 0 ;
42421 PyObject * obj0 = 0 ;
42422 PyObject * obj1 = 0 ;
42423 char *kwnames[] = {
42424 (char *) "self",(char *) "button", NULL
42425 };
42426
42427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
42428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42429 if (SWIG_arg_fail(1)) SWIG_fail;
42430 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42431 if (SWIG_arg_fail(2)) SWIG_fail;
42432 {
42433 PyThreadState* __tstate = wxPyBeginAllowThreads();
42434 (arg1)->AddButton(arg2);
42435
42436 wxPyEndAllowThreads(__tstate);
42437 if (PyErr_Occurred()) SWIG_fail;
42438 }
42439 Py_INCREF(Py_None); resultobj = Py_None;
42440 return resultobj;
42441 fail:
42442 return NULL;
42443 }
42444
42445
42446 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
42447 PyObject *resultobj = NULL;
42448 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42449 PyObject * obj0 = 0 ;
42450 char *kwnames[] = {
42451 (char *) "self", NULL
42452 };
42453
42454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
42455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42456 if (SWIG_arg_fail(1)) SWIG_fail;
42457 {
42458 PyThreadState* __tstate = wxPyBeginAllowThreads();
42459 (arg1)->Realize();
42460
42461 wxPyEndAllowThreads(__tstate);
42462 if (PyErr_Occurred()) SWIG_fail;
42463 }
42464 Py_INCREF(Py_None); resultobj = Py_None;
42465 return resultobj;
42466 fail:
42467 return NULL;
42468 }
42469
42470
42471 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42472 PyObject *resultobj = NULL;
42473 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42474 wxButton *arg2 = (wxButton *) 0 ;
42475 PyObject * obj0 = 0 ;
42476 PyObject * obj1 = 0 ;
42477 char *kwnames[] = {
42478 (char *) "self",(char *) "button", NULL
42479 };
42480
42481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
42482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42483 if (SWIG_arg_fail(1)) SWIG_fail;
42484 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42485 if (SWIG_arg_fail(2)) SWIG_fail;
42486 {
42487 PyThreadState* __tstate = wxPyBeginAllowThreads();
42488 (arg1)->SetAffirmativeButton(arg2);
42489
42490 wxPyEndAllowThreads(__tstate);
42491 if (PyErr_Occurred()) SWIG_fail;
42492 }
42493 Py_INCREF(Py_None); resultobj = Py_None;
42494 return resultobj;
42495 fail:
42496 return NULL;
42497 }
42498
42499
42500 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42501 PyObject *resultobj = NULL;
42502 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42503 wxButton *arg2 = (wxButton *) 0 ;
42504 PyObject * obj0 = 0 ;
42505 PyObject * obj1 = 0 ;
42506 char *kwnames[] = {
42507 (char *) "self",(char *) "button", NULL
42508 };
42509
42510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
42511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42512 if (SWIG_arg_fail(1)) SWIG_fail;
42513 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42514 if (SWIG_arg_fail(2)) SWIG_fail;
42515 {
42516 PyThreadState* __tstate = wxPyBeginAllowThreads();
42517 (arg1)->SetNegativeButton(arg2);
42518
42519 wxPyEndAllowThreads(__tstate);
42520 if (PyErr_Occurred()) SWIG_fail;
42521 }
42522 Py_INCREF(Py_None); resultobj = Py_None;
42523 return resultobj;
42524 fail:
42525 return NULL;
42526 }
42527
42528
42529 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42530 PyObject *resultobj = NULL;
42531 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42532 wxButton *arg2 = (wxButton *) 0 ;
42533 PyObject * obj0 = 0 ;
42534 PyObject * obj1 = 0 ;
42535 char *kwnames[] = {
42536 (char *) "self",(char *) "button", NULL
42537 };
42538
42539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
42540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42541 if (SWIG_arg_fail(1)) SWIG_fail;
42542 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42543 if (SWIG_arg_fail(2)) SWIG_fail;
42544 {
42545 PyThreadState* __tstate = wxPyBeginAllowThreads();
42546 (arg1)->SetCancelButton(arg2);
42547
42548 wxPyEndAllowThreads(__tstate);
42549 if (PyErr_Occurred()) SWIG_fail;
42550 }
42551 Py_INCREF(Py_None); resultobj = Py_None;
42552 return resultobj;
42553 fail:
42554 return NULL;
42555 }
42556
42557
42558 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42559 PyObject *resultobj = NULL;
42560 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42561 wxButton *result;
42562 PyObject * obj0 = 0 ;
42563 char *kwnames[] = {
42564 (char *) "self", NULL
42565 };
42566
42567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
42568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42569 if (SWIG_arg_fail(1)) SWIG_fail;
42570 {
42571 PyThreadState* __tstate = wxPyBeginAllowThreads();
42572 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
42573
42574 wxPyEndAllowThreads(__tstate);
42575 if (PyErr_Occurred()) SWIG_fail;
42576 }
42577 {
42578 resultobj = wxPyMake_wxObject(result, (bool)0);
42579 }
42580 return resultobj;
42581 fail:
42582 return NULL;
42583 }
42584
42585
42586 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
42587 PyObject *resultobj = NULL;
42588 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42589 wxButton *result;
42590 PyObject * obj0 = 0 ;
42591 char *kwnames[] = {
42592 (char *) "self", NULL
42593 };
42594
42595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
42596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42597 if (SWIG_arg_fail(1)) SWIG_fail;
42598 {
42599 PyThreadState* __tstate = wxPyBeginAllowThreads();
42600 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
42601
42602 wxPyEndAllowThreads(__tstate);
42603 if (PyErr_Occurred()) SWIG_fail;
42604 }
42605 {
42606 resultobj = wxPyMake_wxObject(result, (bool)0);
42607 }
42608 return resultobj;
42609 fail:
42610 return NULL;
42611 }
42612
42613
42614 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42615 PyObject *resultobj = NULL;
42616 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42617 wxButton *result;
42618 PyObject * obj0 = 0 ;
42619 char *kwnames[] = {
42620 (char *) "self", NULL
42621 };
42622
42623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
42624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42625 if (SWIG_arg_fail(1)) SWIG_fail;
42626 {
42627 PyThreadState* __tstate = wxPyBeginAllowThreads();
42628 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
42629
42630 wxPyEndAllowThreads(__tstate);
42631 if (PyErr_Occurred()) SWIG_fail;
42632 }
42633 {
42634 resultobj = wxPyMake_wxObject(result, (bool)0);
42635 }
42636 return resultobj;
42637 fail:
42638 return NULL;
42639 }
42640
42641
42642 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42643 PyObject *resultobj = NULL;
42644 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42645 wxButton *result;
42646 PyObject * obj0 = 0 ;
42647 char *kwnames[] = {
42648 (char *) "self", NULL
42649 };
42650
42651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
42652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42653 if (SWIG_arg_fail(1)) SWIG_fail;
42654 {
42655 PyThreadState* __tstate = wxPyBeginAllowThreads();
42656 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
42657
42658 wxPyEndAllowThreads(__tstate);
42659 if (PyErr_Occurred()) SWIG_fail;
42660 }
42661 {
42662 resultobj = wxPyMake_wxObject(result, (bool)0);
42663 }
42664 return resultobj;
42665 fail:
42666 return NULL;
42667 }
42668
42669
42670 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
42671 PyObject *resultobj = NULL;
42672 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42673 wxButton *result;
42674 PyObject * obj0 = 0 ;
42675 char *kwnames[] = {
42676 (char *) "self", NULL
42677 };
42678
42679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
42680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42681 if (SWIG_arg_fail(1)) SWIG_fail;
42682 {
42683 PyThreadState* __tstate = wxPyBeginAllowThreads();
42684 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
42685
42686 wxPyEndAllowThreads(__tstate);
42687 if (PyErr_Occurred()) SWIG_fail;
42688 }
42689 {
42690 resultobj = wxPyMake_wxObject(result, (bool)0);
42691 }
42692 return resultobj;
42693 fail:
42694 return NULL;
42695 }
42696
42697
42698 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
42699 PyObject *obj;
42700 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42701 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
42702 Py_INCREF(obj);
42703 return Py_BuildValue((char *)"");
42704 }
42705 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42706 PyObject *resultobj = NULL;
42707 int arg1 = (int) 0 ;
42708 int arg2 = (int) 0 ;
42709 wxGBPosition *result;
42710 PyObject * obj0 = 0 ;
42711 PyObject * obj1 = 0 ;
42712 char *kwnames[] = {
42713 (char *) "row",(char *) "col", NULL
42714 };
42715
42716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
42717 if (obj0) {
42718 {
42719 arg1 = static_cast<int >(SWIG_As_int(obj0));
42720 if (SWIG_arg_fail(1)) SWIG_fail;
42721 }
42722 }
42723 if (obj1) {
42724 {
42725 arg2 = static_cast<int >(SWIG_As_int(obj1));
42726 if (SWIG_arg_fail(2)) SWIG_fail;
42727 }
42728 }
42729 {
42730 PyThreadState* __tstate = wxPyBeginAllowThreads();
42731 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
42732
42733 wxPyEndAllowThreads(__tstate);
42734 if (PyErr_Occurred()) SWIG_fail;
42735 }
42736 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
42737 return resultobj;
42738 fail:
42739 return NULL;
42740 }
42741
42742
42743 static PyObject *_wrap_delete_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42744 PyObject *resultobj = NULL;
42745 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42746 PyObject * obj0 = 0 ;
42747 char *kwnames[] = {
42748 (char *) "self", NULL
42749 };
42750
42751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GBPosition",kwnames,&obj0)) goto fail;
42752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42753 if (SWIG_arg_fail(1)) SWIG_fail;
42754 {
42755 PyThreadState* __tstate = wxPyBeginAllowThreads();
42756 delete arg1;
42757
42758 wxPyEndAllowThreads(__tstate);
42759 if (PyErr_Occurred()) SWIG_fail;
42760 }
42761 Py_INCREF(Py_None); resultobj = Py_None;
42762 return resultobj;
42763 fail:
42764 return NULL;
42765 }
42766
42767
42768 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42769 PyObject *resultobj = NULL;
42770 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42771 int result;
42772 PyObject * obj0 = 0 ;
42773 char *kwnames[] = {
42774 (char *) "self", NULL
42775 };
42776
42777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
42778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42779 if (SWIG_arg_fail(1)) SWIG_fail;
42780 {
42781 PyThreadState* __tstate = wxPyBeginAllowThreads();
42782 result = (int)((wxGBPosition const *)arg1)->GetRow();
42783
42784 wxPyEndAllowThreads(__tstate);
42785 if (PyErr_Occurred()) SWIG_fail;
42786 }
42787 {
42788 resultobj = SWIG_From_int(static_cast<int >(result));
42789 }
42790 return resultobj;
42791 fail:
42792 return NULL;
42793 }
42794
42795
42796 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42797 PyObject *resultobj = NULL;
42798 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42799 int result;
42800 PyObject * obj0 = 0 ;
42801 char *kwnames[] = {
42802 (char *) "self", NULL
42803 };
42804
42805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
42806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42807 if (SWIG_arg_fail(1)) SWIG_fail;
42808 {
42809 PyThreadState* __tstate = wxPyBeginAllowThreads();
42810 result = (int)((wxGBPosition const *)arg1)->GetCol();
42811
42812 wxPyEndAllowThreads(__tstate);
42813 if (PyErr_Occurred()) SWIG_fail;
42814 }
42815 {
42816 resultobj = SWIG_From_int(static_cast<int >(result));
42817 }
42818 return resultobj;
42819 fail:
42820 return NULL;
42821 }
42822
42823
42824 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42825 PyObject *resultobj = NULL;
42826 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42827 int arg2 ;
42828 PyObject * obj0 = 0 ;
42829 PyObject * obj1 = 0 ;
42830 char *kwnames[] = {
42831 (char *) "self",(char *) "row", NULL
42832 };
42833
42834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
42835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42836 if (SWIG_arg_fail(1)) SWIG_fail;
42837 {
42838 arg2 = static_cast<int >(SWIG_As_int(obj1));
42839 if (SWIG_arg_fail(2)) SWIG_fail;
42840 }
42841 {
42842 PyThreadState* __tstate = wxPyBeginAllowThreads();
42843 (arg1)->SetRow(arg2);
42844
42845 wxPyEndAllowThreads(__tstate);
42846 if (PyErr_Occurred()) SWIG_fail;
42847 }
42848 Py_INCREF(Py_None); resultobj = Py_None;
42849 return resultobj;
42850 fail:
42851 return NULL;
42852 }
42853
42854
42855 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42856 PyObject *resultobj = NULL;
42857 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42858 int arg2 ;
42859 PyObject * obj0 = 0 ;
42860 PyObject * obj1 = 0 ;
42861 char *kwnames[] = {
42862 (char *) "self",(char *) "col", NULL
42863 };
42864
42865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
42866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42867 if (SWIG_arg_fail(1)) SWIG_fail;
42868 {
42869 arg2 = static_cast<int >(SWIG_As_int(obj1));
42870 if (SWIG_arg_fail(2)) SWIG_fail;
42871 }
42872 {
42873 PyThreadState* __tstate = wxPyBeginAllowThreads();
42874 (arg1)->SetCol(arg2);
42875
42876 wxPyEndAllowThreads(__tstate);
42877 if (PyErr_Occurred()) SWIG_fail;
42878 }
42879 Py_INCREF(Py_None); resultobj = Py_None;
42880 return resultobj;
42881 fail:
42882 return NULL;
42883 }
42884
42885
42886 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42887 PyObject *resultobj = NULL;
42888 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42889 wxGBPosition *arg2 = 0 ;
42890 bool result;
42891 wxGBPosition temp2 ;
42892 PyObject * obj0 = 0 ;
42893 PyObject * obj1 = 0 ;
42894 char *kwnames[] = {
42895 (char *) "self",(char *) "other", NULL
42896 };
42897
42898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
42899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42900 if (SWIG_arg_fail(1)) SWIG_fail;
42901 {
42902 arg2 = &temp2;
42903 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42904 }
42905 {
42906 PyThreadState* __tstate = wxPyBeginAllowThreads();
42907 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
42908
42909 wxPyEndAllowThreads(__tstate);
42910 if (PyErr_Occurred()) SWIG_fail;
42911 }
42912 {
42913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42914 }
42915 return resultobj;
42916 fail:
42917 return NULL;
42918 }
42919
42920
42921 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42922 PyObject *resultobj = NULL;
42923 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42924 wxGBPosition *arg2 = 0 ;
42925 bool result;
42926 wxGBPosition temp2 ;
42927 PyObject * obj0 = 0 ;
42928 PyObject * obj1 = 0 ;
42929 char *kwnames[] = {
42930 (char *) "self",(char *) "other", NULL
42931 };
42932
42933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
42934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42935 if (SWIG_arg_fail(1)) SWIG_fail;
42936 {
42937 arg2 = &temp2;
42938 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42939 }
42940 {
42941 PyThreadState* __tstate = wxPyBeginAllowThreads();
42942 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42943
42944 wxPyEndAllowThreads(__tstate);
42945 if (PyErr_Occurred()) SWIG_fail;
42946 }
42947 {
42948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42949 }
42950 return resultobj;
42951 fail:
42952 return NULL;
42953 }
42954
42955
42956 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42957 PyObject *resultobj = NULL;
42958 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42959 int arg2 = (int) 0 ;
42960 int arg3 = (int) 0 ;
42961 PyObject * obj0 = 0 ;
42962 PyObject * obj1 = 0 ;
42963 PyObject * obj2 = 0 ;
42964 char *kwnames[] = {
42965 (char *) "self",(char *) "row",(char *) "col", NULL
42966 };
42967
42968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42970 if (SWIG_arg_fail(1)) SWIG_fail;
42971 if (obj1) {
42972 {
42973 arg2 = static_cast<int >(SWIG_As_int(obj1));
42974 if (SWIG_arg_fail(2)) SWIG_fail;
42975 }
42976 }
42977 if (obj2) {
42978 {
42979 arg3 = static_cast<int >(SWIG_As_int(obj2));
42980 if (SWIG_arg_fail(3)) SWIG_fail;
42981 }
42982 }
42983 {
42984 PyThreadState* __tstate = wxPyBeginAllowThreads();
42985 wxGBPosition_Set(arg1,arg2,arg3);
42986
42987 wxPyEndAllowThreads(__tstate);
42988 if (PyErr_Occurred()) SWIG_fail;
42989 }
42990 Py_INCREF(Py_None); resultobj = Py_None;
42991 return resultobj;
42992 fail:
42993 return NULL;
42994 }
42995
42996
42997 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42998 PyObject *resultobj = NULL;
42999 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
43000 PyObject *result;
43001 PyObject * obj0 = 0 ;
43002 char *kwnames[] = {
43003 (char *) "self", NULL
43004 };
43005
43006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
43007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
43008 if (SWIG_arg_fail(1)) SWIG_fail;
43009 {
43010 PyThreadState* __tstate = wxPyBeginAllowThreads();
43011 result = (PyObject *)wxGBPosition_Get(arg1);
43012
43013 wxPyEndAllowThreads(__tstate);
43014 if (PyErr_Occurred()) SWIG_fail;
43015 }
43016 resultobj = result;
43017 return resultobj;
43018 fail:
43019 return NULL;
43020 }
43021
43022
43023 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
43024 PyObject *obj;
43025 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43026 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
43027 Py_INCREF(obj);
43028 return Py_BuildValue((char *)"");
43029 }
43030 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43031 PyObject *resultobj = NULL;
43032 int arg1 = (int) 1 ;
43033 int arg2 = (int) 1 ;
43034 wxGBSpan *result;
43035 PyObject * obj0 = 0 ;
43036 PyObject * obj1 = 0 ;
43037 char *kwnames[] = {
43038 (char *) "rowspan",(char *) "colspan", NULL
43039 };
43040
43041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
43042 if (obj0) {
43043 {
43044 arg1 = static_cast<int >(SWIG_As_int(obj0));
43045 if (SWIG_arg_fail(1)) SWIG_fail;
43046 }
43047 }
43048 if (obj1) {
43049 {
43050 arg2 = static_cast<int >(SWIG_As_int(obj1));
43051 if (SWIG_arg_fail(2)) SWIG_fail;
43052 }
43053 }
43054 {
43055 PyThreadState* __tstate = wxPyBeginAllowThreads();
43056 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
43057
43058 wxPyEndAllowThreads(__tstate);
43059 if (PyErr_Occurred()) SWIG_fail;
43060 }
43061 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
43062 return resultobj;
43063 fail:
43064 return NULL;
43065 }
43066
43067
43068 static PyObject *_wrap_delete_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43069 PyObject *resultobj = NULL;
43070 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43071 PyObject * obj0 = 0 ;
43072 char *kwnames[] = {
43073 (char *) "self", NULL
43074 };
43075
43076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GBSpan",kwnames,&obj0)) goto fail;
43077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43078 if (SWIG_arg_fail(1)) SWIG_fail;
43079 {
43080 PyThreadState* __tstate = wxPyBeginAllowThreads();
43081 delete arg1;
43082
43083 wxPyEndAllowThreads(__tstate);
43084 if (PyErr_Occurred()) SWIG_fail;
43085 }
43086 Py_INCREF(Py_None); resultobj = Py_None;
43087 return resultobj;
43088 fail:
43089 return NULL;
43090 }
43091
43092
43093 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
43094 PyObject *resultobj = NULL;
43095 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43096 int result;
43097 PyObject * obj0 = 0 ;
43098 char *kwnames[] = {
43099 (char *) "self", NULL
43100 };
43101
43102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
43103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43104 if (SWIG_arg_fail(1)) SWIG_fail;
43105 {
43106 PyThreadState* __tstate = wxPyBeginAllowThreads();
43107 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
43108
43109 wxPyEndAllowThreads(__tstate);
43110 if (PyErr_Occurred()) SWIG_fail;
43111 }
43112 {
43113 resultobj = SWIG_From_int(static_cast<int >(result));
43114 }
43115 return resultobj;
43116 fail:
43117 return NULL;
43118 }
43119
43120
43121 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
43122 PyObject *resultobj = NULL;
43123 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43124 int result;
43125 PyObject * obj0 = 0 ;
43126 char *kwnames[] = {
43127 (char *) "self", NULL
43128 };
43129
43130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
43131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43132 if (SWIG_arg_fail(1)) SWIG_fail;
43133 {
43134 PyThreadState* __tstate = wxPyBeginAllowThreads();
43135 result = (int)((wxGBSpan const *)arg1)->GetColspan();
43136
43137 wxPyEndAllowThreads(__tstate);
43138 if (PyErr_Occurred()) SWIG_fail;
43139 }
43140 {
43141 resultobj = SWIG_From_int(static_cast<int >(result));
43142 }
43143 return resultobj;
43144 fail:
43145 return NULL;
43146 }
43147
43148
43149 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
43150 PyObject *resultobj = NULL;
43151 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43152 int arg2 ;
43153 PyObject * obj0 = 0 ;
43154 PyObject * obj1 = 0 ;
43155 char *kwnames[] = {
43156 (char *) "self",(char *) "rowspan", NULL
43157 };
43158
43159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
43160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43161 if (SWIG_arg_fail(1)) SWIG_fail;
43162 {
43163 arg2 = static_cast<int >(SWIG_As_int(obj1));
43164 if (SWIG_arg_fail(2)) SWIG_fail;
43165 }
43166 {
43167 PyThreadState* __tstate = wxPyBeginAllowThreads();
43168 (arg1)->SetRowspan(arg2);
43169
43170 wxPyEndAllowThreads(__tstate);
43171 if (PyErr_Occurred()) SWIG_fail;
43172 }
43173 Py_INCREF(Py_None); resultobj = Py_None;
43174 return resultobj;
43175 fail:
43176 return NULL;
43177 }
43178
43179
43180 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
43181 PyObject *resultobj = NULL;
43182 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43183 int arg2 ;
43184 PyObject * obj0 = 0 ;
43185 PyObject * obj1 = 0 ;
43186 char *kwnames[] = {
43187 (char *) "self",(char *) "colspan", NULL
43188 };
43189
43190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
43191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43192 if (SWIG_arg_fail(1)) SWIG_fail;
43193 {
43194 arg2 = static_cast<int >(SWIG_As_int(obj1));
43195 if (SWIG_arg_fail(2)) SWIG_fail;
43196 }
43197 {
43198 PyThreadState* __tstate = wxPyBeginAllowThreads();
43199 (arg1)->SetColspan(arg2);
43200
43201 wxPyEndAllowThreads(__tstate);
43202 if (PyErr_Occurred()) SWIG_fail;
43203 }
43204 Py_INCREF(Py_None); resultobj = Py_None;
43205 return resultobj;
43206 fail:
43207 return NULL;
43208 }
43209
43210
43211 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
43212 PyObject *resultobj = NULL;
43213 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43214 wxGBSpan *arg2 = 0 ;
43215 bool result;
43216 wxGBSpan temp2 ;
43217 PyObject * obj0 = 0 ;
43218 PyObject * obj1 = 0 ;
43219 char *kwnames[] = {
43220 (char *) "self",(char *) "other", NULL
43221 };
43222
43223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
43224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43225 if (SWIG_arg_fail(1)) SWIG_fail;
43226 {
43227 arg2 = &temp2;
43228 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43229 }
43230 {
43231 PyThreadState* __tstate = wxPyBeginAllowThreads();
43232 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
43233
43234 wxPyEndAllowThreads(__tstate);
43235 if (PyErr_Occurred()) SWIG_fail;
43236 }
43237 {
43238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43239 }
43240 return resultobj;
43241 fail:
43242 return NULL;
43243 }
43244
43245
43246 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
43247 PyObject *resultobj = NULL;
43248 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43249 wxGBSpan *arg2 = 0 ;
43250 bool result;
43251 wxGBSpan temp2 ;
43252 PyObject * obj0 = 0 ;
43253 PyObject * obj1 = 0 ;
43254 char *kwnames[] = {
43255 (char *) "self",(char *) "other", NULL
43256 };
43257
43258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
43259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43260 if (SWIG_arg_fail(1)) SWIG_fail;
43261 {
43262 arg2 = &temp2;
43263 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43264 }
43265 {
43266 PyThreadState* __tstate = wxPyBeginAllowThreads();
43267 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
43268
43269 wxPyEndAllowThreads(__tstate);
43270 if (PyErr_Occurred()) SWIG_fail;
43271 }
43272 {
43273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43274 }
43275 return resultobj;
43276 fail:
43277 return NULL;
43278 }
43279
43280
43281 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43282 PyObject *resultobj = NULL;
43283 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43284 int arg2 = (int) 1 ;
43285 int arg3 = (int) 1 ;
43286 PyObject * obj0 = 0 ;
43287 PyObject * obj1 = 0 ;
43288 PyObject * obj2 = 0 ;
43289 char *kwnames[] = {
43290 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
43291 };
43292
43293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
43294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43295 if (SWIG_arg_fail(1)) SWIG_fail;
43296 if (obj1) {
43297 {
43298 arg2 = static_cast<int >(SWIG_As_int(obj1));
43299 if (SWIG_arg_fail(2)) SWIG_fail;
43300 }
43301 }
43302 if (obj2) {
43303 {
43304 arg3 = static_cast<int >(SWIG_As_int(obj2));
43305 if (SWIG_arg_fail(3)) SWIG_fail;
43306 }
43307 }
43308 {
43309 PyThreadState* __tstate = wxPyBeginAllowThreads();
43310 wxGBSpan_Set(arg1,arg2,arg3);
43311
43312 wxPyEndAllowThreads(__tstate);
43313 if (PyErr_Occurred()) SWIG_fail;
43314 }
43315 Py_INCREF(Py_None); resultobj = Py_None;
43316 return resultobj;
43317 fail:
43318 return NULL;
43319 }
43320
43321
43322 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
43323 PyObject *resultobj = NULL;
43324 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
43325 PyObject *result;
43326 PyObject * obj0 = 0 ;
43327 char *kwnames[] = {
43328 (char *) "self", NULL
43329 };
43330
43331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
43332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
43333 if (SWIG_arg_fail(1)) SWIG_fail;
43334 {
43335 PyThreadState* __tstate = wxPyBeginAllowThreads();
43336 result = (PyObject *)wxGBSpan_Get(arg1);
43337
43338 wxPyEndAllowThreads(__tstate);
43339 if (PyErr_Occurred()) SWIG_fail;
43340 }
43341 resultobj = result;
43342 return resultobj;
43343 fail:
43344 return NULL;
43345 }
43346
43347
43348 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
43349 PyObject *obj;
43350 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43351 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
43352 Py_INCREF(obj);
43353 return Py_BuildValue((char *)"");
43354 }
43355 static int _wrap_DefaultSpan_set(PyObject *) {
43356 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
43357 return 1;
43358 }
43359
43360
43361 static PyObject *_wrap_DefaultSpan_get(void) {
43362 PyObject *pyobj = NULL;
43363
43364 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
43365 return pyobj;
43366 }
43367
43368
43369 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
43370 PyObject *resultobj = NULL;
43371 wxGBSizerItem *result;
43372 char *kwnames[] = {
43373 NULL
43374 };
43375
43376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
43377 {
43378 PyThreadState* __tstate = wxPyBeginAllowThreads();
43379 result = (wxGBSizerItem *)new wxGBSizerItem();
43380
43381 wxPyEndAllowThreads(__tstate);
43382 if (PyErr_Occurred()) SWIG_fail;
43383 }
43384 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43385 return resultobj;
43386 fail:
43387 return NULL;
43388 }
43389
43390
43391 static PyObject *_wrap_delete_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
43392 PyObject *resultobj = NULL;
43393 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43394 PyObject * obj0 = 0 ;
43395 char *kwnames[] = {
43396 (char *) "self", NULL
43397 };
43398
43399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_GBSizerItem",kwnames,&obj0)) goto fail;
43400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43401 if (SWIG_arg_fail(1)) SWIG_fail;
43402 {
43403 PyThreadState* __tstate = wxPyBeginAllowThreads();
43404 delete arg1;
43405
43406 wxPyEndAllowThreads(__tstate);
43407 if (PyErr_Occurred()) SWIG_fail;
43408 }
43409 Py_INCREF(Py_None); resultobj = Py_None;
43410 return resultobj;
43411 fail:
43412 return NULL;
43413 }
43414
43415
43416 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43417 PyObject *resultobj = NULL;
43418 wxWindow *arg1 = (wxWindow *) 0 ;
43419 wxGBPosition *arg2 = 0 ;
43420 wxGBSpan *arg3 = 0 ;
43421 int arg4 ;
43422 int arg5 ;
43423 PyObject *arg6 = (PyObject *) NULL ;
43424 wxGBSizerItem *result;
43425 wxGBPosition temp2 ;
43426 wxGBSpan temp3 ;
43427 PyObject * obj0 = 0 ;
43428 PyObject * obj1 = 0 ;
43429 PyObject * obj2 = 0 ;
43430 PyObject * obj3 = 0 ;
43431 PyObject * obj4 = 0 ;
43432 PyObject * obj5 = 0 ;
43433 char *kwnames[] = {
43434 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43435 };
43436
43437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43439 if (SWIG_arg_fail(1)) SWIG_fail;
43440 {
43441 arg2 = &temp2;
43442 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43443 }
43444 {
43445 arg3 = &temp3;
43446 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43447 }
43448 {
43449 arg4 = static_cast<int >(SWIG_As_int(obj3));
43450 if (SWIG_arg_fail(4)) SWIG_fail;
43451 }
43452 {
43453 arg5 = static_cast<int >(SWIG_As_int(obj4));
43454 if (SWIG_arg_fail(5)) SWIG_fail;
43455 }
43456 if (obj5) {
43457 arg6 = obj5;
43458 }
43459 {
43460 PyThreadState* __tstate = wxPyBeginAllowThreads();
43461 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43462
43463 wxPyEndAllowThreads(__tstate);
43464 if (PyErr_Occurred()) SWIG_fail;
43465 }
43466 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43467 return resultobj;
43468 fail:
43469 return NULL;
43470 }
43471
43472
43473 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43474 PyObject *resultobj = NULL;
43475 wxSizer *arg1 = (wxSizer *) 0 ;
43476 wxGBPosition *arg2 = 0 ;
43477 wxGBSpan *arg3 = 0 ;
43478 int arg4 ;
43479 int arg5 ;
43480 PyObject *arg6 = (PyObject *) NULL ;
43481 wxGBSizerItem *result;
43482 wxGBPosition temp2 ;
43483 wxGBSpan temp3 ;
43484 PyObject * obj0 = 0 ;
43485 PyObject * obj1 = 0 ;
43486 PyObject * obj2 = 0 ;
43487 PyObject * obj3 = 0 ;
43488 PyObject * obj4 = 0 ;
43489 PyObject * obj5 = 0 ;
43490 char *kwnames[] = {
43491 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43492 };
43493
43494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
43496 if (SWIG_arg_fail(1)) SWIG_fail;
43497 {
43498 arg2 = &temp2;
43499 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43500 }
43501 {
43502 arg3 = &temp3;
43503 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43504 }
43505 {
43506 arg4 = static_cast<int >(SWIG_As_int(obj3));
43507 if (SWIG_arg_fail(4)) SWIG_fail;
43508 }
43509 {
43510 arg5 = static_cast<int >(SWIG_As_int(obj4));
43511 if (SWIG_arg_fail(5)) SWIG_fail;
43512 }
43513 if (obj5) {
43514 arg6 = obj5;
43515 }
43516 {
43517 PyThreadState* __tstate = wxPyBeginAllowThreads();
43518 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43519
43520 wxPyEndAllowThreads(__tstate);
43521 if (PyErr_Occurred()) SWIG_fail;
43522 }
43523 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43524 return resultobj;
43525 fail:
43526 return NULL;
43527 }
43528
43529
43530 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
43531 PyObject *resultobj = NULL;
43532 int arg1 ;
43533 int arg2 ;
43534 wxGBPosition *arg3 = 0 ;
43535 wxGBSpan *arg4 = 0 ;
43536 int arg5 ;
43537 int arg6 ;
43538 PyObject *arg7 = (PyObject *) NULL ;
43539 wxGBSizerItem *result;
43540 wxGBPosition temp3 ;
43541 wxGBSpan temp4 ;
43542 PyObject * obj0 = 0 ;
43543 PyObject * obj1 = 0 ;
43544 PyObject * obj2 = 0 ;
43545 PyObject * obj3 = 0 ;
43546 PyObject * obj4 = 0 ;
43547 PyObject * obj5 = 0 ;
43548 PyObject * obj6 = 0 ;
43549 char *kwnames[] = {
43550 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43551 };
43552
43553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43554 {
43555 arg1 = static_cast<int >(SWIG_As_int(obj0));
43556 if (SWIG_arg_fail(1)) SWIG_fail;
43557 }
43558 {
43559 arg2 = static_cast<int >(SWIG_As_int(obj1));
43560 if (SWIG_arg_fail(2)) SWIG_fail;
43561 }
43562 {
43563 arg3 = &temp3;
43564 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43565 }
43566 {
43567 arg4 = &temp4;
43568 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43569 }
43570 {
43571 arg5 = static_cast<int >(SWIG_As_int(obj4));
43572 if (SWIG_arg_fail(5)) SWIG_fail;
43573 }
43574 {
43575 arg6 = static_cast<int >(SWIG_As_int(obj5));
43576 if (SWIG_arg_fail(6)) SWIG_fail;
43577 }
43578 if (obj6) {
43579 arg7 = obj6;
43580 }
43581 {
43582 PyThreadState* __tstate = wxPyBeginAllowThreads();
43583 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43584
43585 wxPyEndAllowThreads(__tstate);
43586 if (PyErr_Occurred()) SWIG_fail;
43587 }
43588 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43589 return resultobj;
43590 fail:
43591 return NULL;
43592 }
43593
43594
43595 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43596 PyObject *resultobj = NULL;
43597 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43598 wxGBPosition result;
43599 PyObject * obj0 = 0 ;
43600 char *kwnames[] = {
43601 (char *) "self", NULL
43602 };
43603
43604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
43605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43606 if (SWIG_arg_fail(1)) SWIG_fail;
43607 {
43608 PyThreadState* __tstate = wxPyBeginAllowThreads();
43609 result = ((wxGBSizerItem const *)arg1)->GetPos();
43610
43611 wxPyEndAllowThreads(__tstate);
43612 if (PyErr_Occurred()) SWIG_fail;
43613 }
43614 {
43615 wxGBPosition * resultptr;
43616 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
43617 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43618 }
43619 return resultobj;
43620 fail:
43621 return NULL;
43622 }
43623
43624
43625 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43626 PyObject *resultobj = NULL;
43627 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43628 wxGBSpan result;
43629 PyObject * obj0 = 0 ;
43630 char *kwnames[] = {
43631 (char *) "self", NULL
43632 };
43633
43634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
43635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43636 if (SWIG_arg_fail(1)) SWIG_fail;
43637 {
43638 PyThreadState* __tstate = wxPyBeginAllowThreads();
43639 result = ((wxGBSizerItem const *)arg1)->GetSpan();
43640
43641 wxPyEndAllowThreads(__tstate);
43642 if (PyErr_Occurred()) SWIG_fail;
43643 }
43644 {
43645 wxGBSpan * resultptr;
43646 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
43647 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43648 }
43649 return resultobj;
43650 fail:
43651 return NULL;
43652 }
43653
43654
43655 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43656 PyObject *resultobj = NULL;
43657 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43658 wxGBPosition *arg2 = 0 ;
43659 bool result;
43660 wxGBPosition temp2 ;
43661 PyObject * obj0 = 0 ;
43662 PyObject * obj1 = 0 ;
43663 char *kwnames[] = {
43664 (char *) "self",(char *) "pos", NULL
43665 };
43666
43667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
43668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43669 if (SWIG_arg_fail(1)) SWIG_fail;
43670 {
43671 arg2 = &temp2;
43672 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43673 }
43674 {
43675 PyThreadState* __tstate = wxPyBeginAllowThreads();
43676 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
43677
43678 wxPyEndAllowThreads(__tstate);
43679 if (PyErr_Occurred()) SWIG_fail;
43680 }
43681 {
43682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43683 }
43684 return resultobj;
43685 fail:
43686 return NULL;
43687 }
43688
43689
43690 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43691 PyObject *resultobj = NULL;
43692 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43693 wxGBSpan *arg2 = 0 ;
43694 bool result;
43695 wxGBSpan temp2 ;
43696 PyObject * obj0 = 0 ;
43697 PyObject * obj1 = 0 ;
43698 char *kwnames[] = {
43699 (char *) "self",(char *) "span", NULL
43700 };
43701
43702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
43703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43704 if (SWIG_arg_fail(1)) SWIG_fail;
43705 {
43706 arg2 = &temp2;
43707 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43708 }
43709 {
43710 PyThreadState* __tstate = wxPyBeginAllowThreads();
43711 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
43712
43713 wxPyEndAllowThreads(__tstate);
43714 if (PyErr_Occurred()) SWIG_fail;
43715 }
43716 {
43717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43718 }
43719 return resultobj;
43720 fail:
43721 return NULL;
43722 }
43723
43724
43725 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
43726 PyObject *resultobj = NULL;
43727 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43728 wxGBSizerItem *arg2 = 0 ;
43729 bool result;
43730 PyObject * obj0 = 0 ;
43731 PyObject * obj1 = 0 ;
43732 char *kwnames[] = {
43733 (char *) "self",(char *) "other", NULL
43734 };
43735
43736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
43737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43738 if (SWIG_arg_fail(1)) SWIG_fail;
43739 {
43740 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43741 if (SWIG_arg_fail(2)) SWIG_fail;
43742 if (arg2 == NULL) {
43743 SWIG_null_ref("wxGBSizerItem");
43744 }
43745 if (SWIG_arg_fail(2)) SWIG_fail;
43746 }
43747 {
43748 PyThreadState* __tstate = wxPyBeginAllowThreads();
43749 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
43750
43751 wxPyEndAllowThreads(__tstate);
43752 if (PyErr_Occurred()) SWIG_fail;
43753 }
43754 {
43755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43756 }
43757 return resultobj;
43758 fail:
43759 return NULL;
43760 }
43761
43762
43763 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
43764 PyObject *resultobj = NULL;
43765 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43766 wxGBPosition *arg2 = 0 ;
43767 wxGBSpan *arg3 = 0 ;
43768 bool result;
43769 wxGBPosition temp2 ;
43770 wxGBSpan temp3 ;
43771 PyObject * obj0 = 0 ;
43772 PyObject * obj1 = 0 ;
43773 PyObject * obj2 = 0 ;
43774 char *kwnames[] = {
43775 (char *) "self",(char *) "pos",(char *) "span", NULL
43776 };
43777
43778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
43779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43780 if (SWIG_arg_fail(1)) SWIG_fail;
43781 {
43782 arg2 = &temp2;
43783 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43784 }
43785 {
43786 arg3 = &temp3;
43787 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43788 }
43789 {
43790 PyThreadState* __tstate = wxPyBeginAllowThreads();
43791 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
43792
43793 wxPyEndAllowThreads(__tstate);
43794 if (PyErr_Occurred()) SWIG_fail;
43795 }
43796 {
43797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43798 }
43799 return resultobj;
43800 fail:
43801 return NULL;
43802 }
43803
43804
43805 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
43806 PyObject *resultobj = NULL;
43807 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43808 wxGBPosition result;
43809 PyObject * obj0 = 0 ;
43810 char *kwnames[] = {
43811 (char *) "self", NULL
43812 };
43813
43814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
43815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43816 if (SWIG_arg_fail(1)) SWIG_fail;
43817 {
43818 PyThreadState* __tstate = wxPyBeginAllowThreads();
43819 result = wxGBSizerItem_GetEndPos(arg1);
43820
43821 wxPyEndAllowThreads(__tstate);
43822 if (PyErr_Occurred()) SWIG_fail;
43823 }
43824 {
43825 wxGBPosition * resultptr;
43826 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
43827 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43828 }
43829 return resultobj;
43830 fail:
43831 return NULL;
43832 }
43833
43834
43835 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43836 PyObject *resultobj = NULL;
43837 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43838 wxGridBagSizer *result;
43839 PyObject * obj0 = 0 ;
43840 char *kwnames[] = {
43841 (char *) "self", NULL
43842 };
43843
43844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
43845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43846 if (SWIG_arg_fail(1)) SWIG_fail;
43847 {
43848 PyThreadState* __tstate = wxPyBeginAllowThreads();
43849 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
43850
43851 wxPyEndAllowThreads(__tstate);
43852 if (PyErr_Occurred()) SWIG_fail;
43853 }
43854 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
43855 return resultobj;
43856 fail:
43857 return NULL;
43858 }
43859
43860
43861 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43862 PyObject *resultobj = NULL;
43863 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43864 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
43865 PyObject * obj0 = 0 ;
43866 PyObject * obj1 = 0 ;
43867 char *kwnames[] = {
43868 (char *) "self",(char *) "sizer", NULL
43869 };
43870
43871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
43872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43873 if (SWIG_arg_fail(1)) SWIG_fail;
43874 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43875 if (SWIG_arg_fail(2)) SWIG_fail;
43876 {
43877 PyThreadState* __tstate = wxPyBeginAllowThreads();
43878 (arg1)->SetGBSizer(arg2);
43879
43880 wxPyEndAllowThreads(__tstate);
43881 if (PyErr_Occurred()) SWIG_fail;
43882 }
43883 Py_INCREF(Py_None); resultobj = Py_None;
43884 return resultobj;
43885 fail:
43886 return NULL;
43887 }
43888
43889
43890 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
43891 PyObject *obj;
43892 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43893 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
43894 Py_INCREF(obj);
43895 return Py_BuildValue((char *)"");
43896 }
43897 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43898 PyObject *resultobj = NULL;
43899 int arg1 = (int) 0 ;
43900 int arg2 = (int) 0 ;
43901 wxGridBagSizer *result;
43902 PyObject * obj0 = 0 ;
43903 PyObject * obj1 = 0 ;
43904 char *kwnames[] = {
43905 (char *) "vgap",(char *) "hgap", NULL
43906 };
43907
43908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
43909 if (obj0) {
43910 {
43911 arg1 = static_cast<int >(SWIG_As_int(obj0));
43912 if (SWIG_arg_fail(1)) SWIG_fail;
43913 }
43914 }
43915 if (obj1) {
43916 {
43917 arg2 = static_cast<int >(SWIG_As_int(obj1));
43918 if (SWIG_arg_fail(2)) SWIG_fail;
43919 }
43920 }
43921 {
43922 PyThreadState* __tstate = wxPyBeginAllowThreads();
43923 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
43924
43925 wxPyEndAllowThreads(__tstate);
43926 if (PyErr_Occurred()) SWIG_fail;
43927 }
43928 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
43929 return resultobj;
43930 fail:
43931 return NULL;
43932 }
43933
43934
43935 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
43936 PyObject *resultobj = NULL;
43937 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43938 PyObject *arg2 = (PyObject *) 0 ;
43939 wxGBPosition *arg3 = 0 ;
43940 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
43941 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
43942 int arg5 = (int) 0 ;
43943 int arg6 = (int) 0 ;
43944 PyObject *arg7 = (PyObject *) NULL ;
43945 wxGBSizerItem *result;
43946 wxGBPosition temp3 ;
43947 wxGBSpan temp4 ;
43948 PyObject * obj0 = 0 ;
43949 PyObject * obj1 = 0 ;
43950 PyObject * obj2 = 0 ;
43951 PyObject * obj3 = 0 ;
43952 PyObject * obj4 = 0 ;
43953 PyObject * obj5 = 0 ;
43954 PyObject * obj6 = 0 ;
43955 char *kwnames[] = {
43956 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43957 };
43958
43959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43961 if (SWIG_arg_fail(1)) SWIG_fail;
43962 arg2 = obj1;
43963 {
43964 arg3 = &temp3;
43965 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43966 }
43967 if (obj3) {
43968 {
43969 arg4 = &temp4;
43970 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43971 }
43972 }
43973 if (obj4) {
43974 {
43975 arg5 = static_cast<int >(SWIG_As_int(obj4));
43976 if (SWIG_arg_fail(5)) SWIG_fail;
43977 }
43978 }
43979 if (obj5) {
43980 {
43981 arg6 = static_cast<int >(SWIG_As_int(obj5));
43982 if (SWIG_arg_fail(6)) SWIG_fail;
43983 }
43984 }
43985 if (obj6) {
43986 arg7 = obj6;
43987 }
43988 {
43989 PyThreadState* __tstate = wxPyBeginAllowThreads();
43990 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43991
43992 wxPyEndAllowThreads(__tstate);
43993 if (PyErr_Occurred()) SWIG_fail;
43994 }
43995 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43996 return resultobj;
43997 fail:
43998 return NULL;
43999 }
44000
44001
44002 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
44003 PyObject *resultobj = NULL;
44004 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44005 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44006 wxGBSizerItem *result;
44007 PyObject * obj0 = 0 ;
44008 PyObject * obj1 = 0 ;
44009 char *kwnames[] = {
44010 (char *) "self",(char *) "item", NULL
44011 };
44012
44013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
44014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44015 if (SWIG_arg_fail(1)) SWIG_fail;
44016 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
44017 if (SWIG_arg_fail(2)) SWIG_fail;
44018 {
44019 PyThreadState* __tstate = wxPyBeginAllowThreads();
44020 result = (wxGBSizerItem *)(arg1)->Add(arg2);
44021
44022 wxPyEndAllowThreads(__tstate);
44023 if (PyErr_Occurred()) SWIG_fail;
44024 }
44025 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44026 return resultobj;
44027 fail:
44028 return NULL;
44029 }
44030
44031
44032 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
44033 PyObject *resultobj = NULL;
44034 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44035 int arg2 ;
44036 int arg3 ;
44037 wxSize result;
44038 PyObject * obj0 = 0 ;
44039 PyObject * obj1 = 0 ;
44040 PyObject * obj2 = 0 ;
44041 char *kwnames[] = {
44042 (char *) "self",(char *) "row",(char *) "col", NULL
44043 };
44044
44045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
44046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44047 if (SWIG_arg_fail(1)) SWIG_fail;
44048 {
44049 arg2 = static_cast<int >(SWIG_As_int(obj1));
44050 if (SWIG_arg_fail(2)) SWIG_fail;
44051 }
44052 {
44053 arg3 = static_cast<int >(SWIG_As_int(obj2));
44054 if (SWIG_arg_fail(3)) SWIG_fail;
44055 }
44056 {
44057 PyThreadState* __tstate = wxPyBeginAllowThreads();
44058 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
44059
44060 wxPyEndAllowThreads(__tstate);
44061 if (PyErr_Occurred()) SWIG_fail;
44062 }
44063 {
44064 wxSize * resultptr;
44065 resultptr = new wxSize(static_cast<wxSize & >(result));
44066 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
44067 }
44068 return resultobj;
44069 fail:
44070 return NULL;
44071 }
44072
44073
44074 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
44075 PyObject *resultobj = NULL;
44076 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44077 wxSize result;
44078 PyObject * obj0 = 0 ;
44079 char *kwnames[] = {
44080 (char *) "self", NULL
44081 };
44082
44083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
44084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44085 if (SWIG_arg_fail(1)) SWIG_fail;
44086 {
44087 PyThreadState* __tstate = wxPyBeginAllowThreads();
44088 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
44089
44090 wxPyEndAllowThreads(__tstate);
44091 if (PyErr_Occurred()) SWIG_fail;
44092 }
44093 {
44094 wxSize * resultptr;
44095 resultptr = new wxSize(static_cast<wxSize & >(result));
44096 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
44097 }
44098 return resultobj;
44099 fail:
44100 return NULL;
44101 }
44102
44103
44104 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
44105 PyObject *resultobj = NULL;
44106 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44107 wxSize *arg2 = 0 ;
44108 wxSize temp2 ;
44109 PyObject * obj0 = 0 ;
44110 PyObject * obj1 = 0 ;
44111 char *kwnames[] = {
44112 (char *) "self",(char *) "sz", NULL
44113 };
44114
44115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
44116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44117 if (SWIG_arg_fail(1)) SWIG_fail;
44118 {
44119 arg2 = &temp2;
44120 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
44121 }
44122 {
44123 PyThreadState* __tstate = wxPyBeginAllowThreads();
44124 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
44125
44126 wxPyEndAllowThreads(__tstate);
44127 if (PyErr_Occurred()) SWIG_fail;
44128 }
44129 Py_INCREF(Py_None); resultobj = Py_None;
44130 return resultobj;
44131 fail:
44132 return NULL;
44133 }
44134
44135
44136 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
44137 PyObject *resultobj = NULL;
44138 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44139 wxWindow *arg2 = (wxWindow *) 0 ;
44140 wxGBPosition result;
44141 PyObject * obj0 = 0 ;
44142 PyObject * obj1 = 0 ;
44143
44144 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44146 if (SWIG_arg_fail(1)) SWIG_fail;
44147 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44148 if (SWIG_arg_fail(2)) SWIG_fail;
44149 {
44150 PyThreadState* __tstate = wxPyBeginAllowThreads();
44151 result = (arg1)->GetItemPosition(arg2);
44152
44153 wxPyEndAllowThreads(__tstate);
44154 if (PyErr_Occurred()) SWIG_fail;
44155 }
44156 {
44157 wxGBPosition * resultptr;
44158 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44159 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44160 }
44161 return resultobj;
44162 fail:
44163 return NULL;
44164 }
44165
44166
44167 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
44168 PyObject *resultobj = NULL;
44169 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44170 wxSizer *arg2 = (wxSizer *) 0 ;
44171 wxGBPosition result;
44172 PyObject * obj0 = 0 ;
44173 PyObject * obj1 = 0 ;
44174
44175 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44177 if (SWIG_arg_fail(1)) SWIG_fail;
44178 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44179 if (SWIG_arg_fail(2)) SWIG_fail;
44180 {
44181 PyThreadState* __tstate = wxPyBeginAllowThreads();
44182 result = (arg1)->GetItemPosition(arg2);
44183
44184 wxPyEndAllowThreads(__tstate);
44185 if (PyErr_Occurred()) SWIG_fail;
44186 }
44187 {
44188 wxGBPosition * resultptr;
44189 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44190 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44191 }
44192 return resultobj;
44193 fail:
44194 return NULL;
44195 }
44196
44197
44198 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44199 PyObject *resultobj = NULL;
44200 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44201 size_t arg2 ;
44202 wxGBPosition result;
44203 PyObject * obj0 = 0 ;
44204 PyObject * obj1 = 0 ;
44205
44206 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
44207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44208 if (SWIG_arg_fail(1)) SWIG_fail;
44209 {
44210 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44211 if (SWIG_arg_fail(2)) SWIG_fail;
44212 }
44213 {
44214 PyThreadState* __tstate = wxPyBeginAllowThreads();
44215 result = (arg1)->GetItemPosition(arg2);
44216
44217 wxPyEndAllowThreads(__tstate);
44218 if (PyErr_Occurred()) SWIG_fail;
44219 }
44220 {
44221 wxGBPosition * resultptr;
44222 resultptr = new wxGBPosition(static_cast<wxGBPosition & >(result));
44223 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
44224 }
44225 return resultobj;
44226 fail:
44227 return NULL;
44228 }
44229
44230
44231 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
44232 int argc;
44233 PyObject *argv[3];
44234 int ii;
44235
44236 argc = PyObject_Length(args);
44237 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44238 argv[ii] = PyTuple_GetItem(args,ii);
44239 }
44240 if (argc == 2) {
44241 int _v;
44242 {
44243 void *ptr;
44244 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44245 _v = 0;
44246 PyErr_Clear();
44247 } else {
44248 _v = 1;
44249 }
44250 }
44251 if (_v) {
44252 {
44253 void *ptr;
44254 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44255 _v = 0;
44256 PyErr_Clear();
44257 } else {
44258 _v = 1;
44259 }
44260 }
44261 if (_v) {
44262 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
44263 }
44264 }
44265 }
44266 if (argc == 2) {
44267 int _v;
44268 {
44269 void *ptr;
44270 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44271 _v = 0;
44272 PyErr_Clear();
44273 } else {
44274 _v = 1;
44275 }
44276 }
44277 if (_v) {
44278 {
44279 void *ptr;
44280 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44281 _v = 0;
44282 PyErr_Clear();
44283 } else {
44284 _v = 1;
44285 }
44286 }
44287 if (_v) {
44288 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
44289 }
44290 }
44291 }
44292 if (argc == 2) {
44293 int _v;
44294 {
44295 void *ptr;
44296 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44297 _v = 0;
44298 PyErr_Clear();
44299 } else {
44300 _v = 1;
44301 }
44302 }
44303 if (_v) {
44304 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44305 if (_v) {
44306 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
44307 }
44308 }
44309 }
44310
44311 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
44312 return NULL;
44313 }
44314
44315
44316 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
44317 PyObject *resultobj = NULL;
44318 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44319 wxWindow *arg2 = (wxWindow *) 0 ;
44320 wxGBPosition *arg3 = 0 ;
44321 bool result;
44322 wxGBPosition temp3 ;
44323 PyObject * obj0 = 0 ;
44324 PyObject * obj1 = 0 ;
44325 PyObject * obj2 = 0 ;
44326
44327 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44329 if (SWIG_arg_fail(1)) SWIG_fail;
44330 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44331 if (SWIG_arg_fail(2)) SWIG_fail;
44332 {
44333 arg3 = &temp3;
44334 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44335 }
44336 {
44337 PyThreadState* __tstate = wxPyBeginAllowThreads();
44338 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44339
44340 wxPyEndAllowThreads(__tstate);
44341 if (PyErr_Occurred()) SWIG_fail;
44342 }
44343 {
44344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44345 }
44346 return resultobj;
44347 fail:
44348 return NULL;
44349 }
44350
44351
44352 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
44353 PyObject *resultobj = NULL;
44354 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44355 wxSizer *arg2 = (wxSizer *) 0 ;
44356 wxGBPosition *arg3 = 0 ;
44357 bool result;
44358 wxGBPosition temp3 ;
44359 PyObject * obj0 = 0 ;
44360 PyObject * obj1 = 0 ;
44361 PyObject * obj2 = 0 ;
44362
44363 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44365 if (SWIG_arg_fail(1)) SWIG_fail;
44366 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44367 if (SWIG_arg_fail(2)) SWIG_fail;
44368 {
44369 arg3 = &temp3;
44370 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44371 }
44372 {
44373 PyThreadState* __tstate = wxPyBeginAllowThreads();
44374 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44375
44376 wxPyEndAllowThreads(__tstate);
44377 if (PyErr_Occurred()) SWIG_fail;
44378 }
44379 {
44380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44381 }
44382 return resultobj;
44383 fail:
44384 return NULL;
44385 }
44386
44387
44388 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
44389 PyObject *resultobj = NULL;
44390 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44391 size_t arg2 ;
44392 wxGBPosition *arg3 = 0 ;
44393 bool result;
44394 wxGBPosition temp3 ;
44395 PyObject * obj0 = 0 ;
44396 PyObject * obj1 = 0 ;
44397 PyObject * obj2 = 0 ;
44398
44399 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
44400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44401 if (SWIG_arg_fail(1)) SWIG_fail;
44402 {
44403 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44404 if (SWIG_arg_fail(2)) SWIG_fail;
44405 }
44406 {
44407 arg3 = &temp3;
44408 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
44409 }
44410 {
44411 PyThreadState* __tstate = wxPyBeginAllowThreads();
44412 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
44413
44414 wxPyEndAllowThreads(__tstate);
44415 if (PyErr_Occurred()) SWIG_fail;
44416 }
44417 {
44418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44419 }
44420 return resultobj;
44421 fail:
44422 return NULL;
44423 }
44424
44425
44426 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
44427 int argc;
44428 PyObject *argv[4];
44429 int ii;
44430
44431 argc = PyObject_Length(args);
44432 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44433 argv[ii] = PyTuple_GetItem(args,ii);
44434 }
44435 if (argc == 3) {
44436 int _v;
44437 {
44438 void *ptr;
44439 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44440 _v = 0;
44441 PyErr_Clear();
44442 } else {
44443 _v = 1;
44444 }
44445 }
44446 if (_v) {
44447 {
44448 void *ptr;
44449 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44450 _v = 0;
44451 PyErr_Clear();
44452 } else {
44453 _v = 1;
44454 }
44455 }
44456 if (_v) {
44457 {
44458 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44459 }
44460 if (_v) {
44461 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
44462 }
44463 }
44464 }
44465 }
44466 if (argc == 3) {
44467 int _v;
44468 {
44469 void *ptr;
44470 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44471 _v = 0;
44472 PyErr_Clear();
44473 } else {
44474 _v = 1;
44475 }
44476 }
44477 if (_v) {
44478 {
44479 void *ptr;
44480 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44481 _v = 0;
44482 PyErr_Clear();
44483 } else {
44484 _v = 1;
44485 }
44486 }
44487 if (_v) {
44488 {
44489 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44490 }
44491 if (_v) {
44492 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
44493 }
44494 }
44495 }
44496 }
44497 if (argc == 3) {
44498 int _v;
44499 {
44500 void *ptr;
44501 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44502 _v = 0;
44503 PyErr_Clear();
44504 } else {
44505 _v = 1;
44506 }
44507 }
44508 if (_v) {
44509 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44510 if (_v) {
44511 {
44512 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44513 }
44514 if (_v) {
44515 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
44516 }
44517 }
44518 }
44519 }
44520
44521 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
44522 return NULL;
44523 }
44524
44525
44526 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44527 PyObject *resultobj = NULL;
44528 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44529 wxWindow *arg2 = (wxWindow *) 0 ;
44530 wxGBSpan result;
44531 PyObject * obj0 = 0 ;
44532 PyObject * obj1 = 0 ;
44533
44534 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44536 if (SWIG_arg_fail(1)) SWIG_fail;
44537 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44538 if (SWIG_arg_fail(2)) SWIG_fail;
44539 {
44540 PyThreadState* __tstate = wxPyBeginAllowThreads();
44541 result = (arg1)->GetItemSpan(arg2);
44542
44543 wxPyEndAllowThreads(__tstate);
44544 if (PyErr_Occurred()) SWIG_fail;
44545 }
44546 {
44547 wxGBSpan * resultptr;
44548 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44549 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44550 }
44551 return resultobj;
44552 fail:
44553 return NULL;
44554 }
44555
44556
44557 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44558 PyObject *resultobj = NULL;
44559 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44560 wxSizer *arg2 = (wxSizer *) 0 ;
44561 wxGBSpan result;
44562 PyObject * obj0 = 0 ;
44563 PyObject * obj1 = 0 ;
44564
44565 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44567 if (SWIG_arg_fail(1)) SWIG_fail;
44568 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44569 if (SWIG_arg_fail(2)) SWIG_fail;
44570 {
44571 PyThreadState* __tstate = wxPyBeginAllowThreads();
44572 result = (arg1)->GetItemSpan(arg2);
44573
44574 wxPyEndAllowThreads(__tstate);
44575 if (PyErr_Occurred()) SWIG_fail;
44576 }
44577 {
44578 wxGBSpan * resultptr;
44579 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44580 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44581 }
44582 return resultobj;
44583 fail:
44584 return NULL;
44585 }
44586
44587
44588 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44589 PyObject *resultobj = NULL;
44590 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44591 size_t arg2 ;
44592 wxGBSpan result;
44593 PyObject * obj0 = 0 ;
44594 PyObject * obj1 = 0 ;
44595
44596 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44598 if (SWIG_arg_fail(1)) SWIG_fail;
44599 {
44600 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44601 if (SWIG_arg_fail(2)) SWIG_fail;
44602 }
44603 {
44604 PyThreadState* __tstate = wxPyBeginAllowThreads();
44605 result = (arg1)->GetItemSpan(arg2);
44606
44607 wxPyEndAllowThreads(__tstate);
44608 if (PyErr_Occurred()) SWIG_fail;
44609 }
44610 {
44611 wxGBSpan * resultptr;
44612 resultptr = new wxGBSpan(static_cast<wxGBSpan & >(result));
44613 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44614 }
44615 return resultobj;
44616 fail:
44617 return NULL;
44618 }
44619
44620
44621 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
44622 int argc;
44623 PyObject *argv[3];
44624 int ii;
44625
44626 argc = PyObject_Length(args);
44627 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44628 argv[ii] = PyTuple_GetItem(args,ii);
44629 }
44630 if (argc == 2) {
44631 int _v;
44632 {
44633 void *ptr;
44634 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44635 _v = 0;
44636 PyErr_Clear();
44637 } else {
44638 _v = 1;
44639 }
44640 }
44641 if (_v) {
44642 {
44643 void *ptr;
44644 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44645 _v = 0;
44646 PyErr_Clear();
44647 } else {
44648 _v = 1;
44649 }
44650 }
44651 if (_v) {
44652 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
44653 }
44654 }
44655 }
44656 if (argc == 2) {
44657 int _v;
44658 {
44659 void *ptr;
44660 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44661 _v = 0;
44662 PyErr_Clear();
44663 } else {
44664 _v = 1;
44665 }
44666 }
44667 if (_v) {
44668 {
44669 void *ptr;
44670 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44671 _v = 0;
44672 PyErr_Clear();
44673 } else {
44674 _v = 1;
44675 }
44676 }
44677 if (_v) {
44678 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
44679 }
44680 }
44681 }
44682 if (argc == 2) {
44683 int _v;
44684 {
44685 void *ptr;
44686 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44687 _v = 0;
44688 PyErr_Clear();
44689 } else {
44690 _v = 1;
44691 }
44692 }
44693 if (_v) {
44694 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44695 if (_v) {
44696 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
44697 }
44698 }
44699 }
44700
44701 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
44702 return NULL;
44703 }
44704
44705
44706 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44707 PyObject *resultobj = NULL;
44708 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44709 wxWindow *arg2 = (wxWindow *) 0 ;
44710 wxGBSpan *arg3 = 0 ;
44711 bool result;
44712 wxGBSpan temp3 ;
44713 PyObject * obj0 = 0 ;
44714 PyObject * obj1 = 0 ;
44715 PyObject * obj2 = 0 ;
44716
44717 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44719 if (SWIG_arg_fail(1)) SWIG_fail;
44720 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44721 if (SWIG_arg_fail(2)) SWIG_fail;
44722 {
44723 arg3 = &temp3;
44724 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44725 }
44726 {
44727 PyThreadState* __tstate = wxPyBeginAllowThreads();
44728 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44729
44730 wxPyEndAllowThreads(__tstate);
44731 if (PyErr_Occurred()) SWIG_fail;
44732 }
44733 {
44734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44735 }
44736 return resultobj;
44737 fail:
44738 return NULL;
44739 }
44740
44741
44742 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44743 PyObject *resultobj = NULL;
44744 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44745 wxSizer *arg2 = (wxSizer *) 0 ;
44746 wxGBSpan *arg3 = 0 ;
44747 bool result;
44748 wxGBSpan temp3 ;
44749 PyObject * obj0 = 0 ;
44750 PyObject * obj1 = 0 ;
44751 PyObject * obj2 = 0 ;
44752
44753 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44755 if (SWIG_arg_fail(1)) SWIG_fail;
44756 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44757 if (SWIG_arg_fail(2)) SWIG_fail;
44758 {
44759 arg3 = &temp3;
44760 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44761 }
44762 {
44763 PyThreadState* __tstate = wxPyBeginAllowThreads();
44764 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44765
44766 wxPyEndAllowThreads(__tstate);
44767 if (PyErr_Occurred()) SWIG_fail;
44768 }
44769 {
44770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44771 }
44772 return resultobj;
44773 fail:
44774 return NULL;
44775 }
44776
44777
44778 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44779 PyObject *resultobj = NULL;
44780 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44781 size_t arg2 ;
44782 wxGBSpan *arg3 = 0 ;
44783 bool result;
44784 wxGBSpan temp3 ;
44785 PyObject * obj0 = 0 ;
44786 PyObject * obj1 = 0 ;
44787 PyObject * obj2 = 0 ;
44788
44789 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44791 if (SWIG_arg_fail(1)) SWIG_fail;
44792 {
44793 arg2 = static_cast<size_t >(SWIG_As_unsigned_SS_long(obj1));
44794 if (SWIG_arg_fail(2)) SWIG_fail;
44795 }
44796 {
44797 arg3 = &temp3;
44798 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44799 }
44800 {
44801 PyThreadState* __tstate = wxPyBeginAllowThreads();
44802 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44803
44804 wxPyEndAllowThreads(__tstate);
44805 if (PyErr_Occurred()) SWIG_fail;
44806 }
44807 {
44808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44809 }
44810 return resultobj;
44811 fail:
44812 return NULL;
44813 }
44814
44815
44816 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
44817 int argc;
44818 PyObject *argv[4];
44819 int ii;
44820
44821 argc = PyObject_Length(args);
44822 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44823 argv[ii] = PyTuple_GetItem(args,ii);
44824 }
44825 if (argc == 3) {
44826 int _v;
44827 {
44828 void *ptr;
44829 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44830 _v = 0;
44831 PyErr_Clear();
44832 } else {
44833 _v = 1;
44834 }
44835 }
44836 if (_v) {
44837 {
44838 void *ptr;
44839 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44840 _v = 0;
44841 PyErr_Clear();
44842 } else {
44843 _v = 1;
44844 }
44845 }
44846 if (_v) {
44847 {
44848 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44849 }
44850 if (_v) {
44851 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
44852 }
44853 }
44854 }
44855 }
44856 if (argc == 3) {
44857 int _v;
44858 {
44859 void *ptr;
44860 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44861 _v = 0;
44862 PyErr_Clear();
44863 } else {
44864 _v = 1;
44865 }
44866 }
44867 if (_v) {
44868 {
44869 void *ptr;
44870 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44871 _v = 0;
44872 PyErr_Clear();
44873 } else {
44874 _v = 1;
44875 }
44876 }
44877 if (_v) {
44878 {
44879 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44880 }
44881 if (_v) {
44882 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
44883 }
44884 }
44885 }
44886 }
44887 if (argc == 3) {
44888 int _v;
44889 {
44890 void *ptr;
44891 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44892 _v = 0;
44893 PyErr_Clear();
44894 } else {
44895 _v = 1;
44896 }
44897 }
44898 if (_v) {
44899 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44900 if (_v) {
44901 {
44902 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44903 }
44904 if (_v) {
44905 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
44906 }
44907 }
44908 }
44909 }
44910
44911 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
44912 return NULL;
44913 }
44914
44915
44916 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
44917 PyObject *resultobj = NULL;
44918 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44919 wxWindow *arg2 = (wxWindow *) 0 ;
44920 wxGBSizerItem *result;
44921 PyObject * obj0 = 0 ;
44922 PyObject * obj1 = 0 ;
44923
44924 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44926 if (SWIG_arg_fail(1)) SWIG_fail;
44927 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44928 if (SWIG_arg_fail(2)) SWIG_fail;
44929 {
44930 PyThreadState* __tstate = wxPyBeginAllowThreads();
44931 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44932
44933 wxPyEndAllowThreads(__tstate);
44934 if (PyErr_Occurred()) SWIG_fail;
44935 }
44936 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44937 return resultobj;
44938 fail:
44939 return NULL;
44940 }
44941
44942
44943 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
44944 PyObject *resultobj = NULL;
44945 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44946 wxSizer *arg2 = (wxSizer *) 0 ;
44947 wxGBSizerItem *result;
44948 PyObject * obj0 = 0 ;
44949 PyObject * obj1 = 0 ;
44950
44951 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44953 if (SWIG_arg_fail(1)) SWIG_fail;
44954 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44955 if (SWIG_arg_fail(2)) SWIG_fail;
44956 {
44957 PyThreadState* __tstate = wxPyBeginAllowThreads();
44958 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44959
44960 wxPyEndAllowThreads(__tstate);
44961 if (PyErr_Occurred()) SWIG_fail;
44962 }
44963 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44964 return resultobj;
44965 fail:
44966 return NULL;
44967 }
44968
44969
44970 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
44971 int argc;
44972 PyObject *argv[3];
44973 int ii;
44974
44975 argc = PyObject_Length(args);
44976 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44977 argv[ii] = PyTuple_GetItem(args,ii);
44978 }
44979 if (argc == 2) {
44980 int _v;
44981 {
44982 void *ptr;
44983 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44984 _v = 0;
44985 PyErr_Clear();
44986 } else {
44987 _v = 1;
44988 }
44989 }
44990 if (_v) {
44991 {
44992 void *ptr;
44993 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44994 _v = 0;
44995 PyErr_Clear();
44996 } else {
44997 _v = 1;
44998 }
44999 }
45000 if (_v) {
45001 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
45002 }
45003 }
45004 }
45005 if (argc == 2) {
45006 int _v;
45007 {
45008 void *ptr;
45009 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
45010 _v = 0;
45011 PyErr_Clear();
45012 } else {
45013 _v = 1;
45014 }
45015 }
45016 if (_v) {
45017 {
45018 void *ptr;
45019 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
45020 _v = 0;
45021 PyErr_Clear();
45022 } else {
45023 _v = 1;
45024 }
45025 }
45026 if (_v) {
45027 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
45028 }
45029 }
45030 }
45031
45032 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
45033 return NULL;
45034 }
45035
45036
45037 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
45038 PyObject *resultobj = NULL;
45039 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45040 wxGBPosition *arg2 = 0 ;
45041 wxGBSizerItem *result;
45042 wxGBPosition temp2 ;
45043 PyObject * obj0 = 0 ;
45044 PyObject * obj1 = 0 ;
45045 char *kwnames[] = {
45046 (char *) "self",(char *) "pos", NULL
45047 };
45048
45049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
45050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45051 if (SWIG_arg_fail(1)) SWIG_fail;
45052 {
45053 arg2 = &temp2;
45054 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
45055 }
45056 {
45057 PyThreadState* __tstate = wxPyBeginAllowThreads();
45058 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
45059
45060 wxPyEndAllowThreads(__tstate);
45061 if (PyErr_Occurred()) SWIG_fail;
45062 }
45063 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
45064 return resultobj;
45065 fail:
45066 return NULL;
45067 }
45068
45069
45070 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
45071 PyObject *resultobj = NULL;
45072 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45073 wxPoint *arg2 = 0 ;
45074 wxGBSizerItem *result;
45075 wxPoint temp2 ;
45076 PyObject * obj0 = 0 ;
45077 PyObject * obj1 = 0 ;
45078 char *kwnames[] = {
45079 (char *) "self",(char *) "pt", NULL
45080 };
45081
45082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
45083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45084 if (SWIG_arg_fail(1)) SWIG_fail;
45085 {
45086 arg2 = &temp2;
45087 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45088 }
45089 {
45090 PyThreadState* __tstate = wxPyBeginAllowThreads();
45091 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
45092
45093 wxPyEndAllowThreads(__tstate);
45094 if (PyErr_Occurred()) SWIG_fail;
45095 }
45096 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
45097 return resultobj;
45098 fail:
45099 return NULL;
45100 }
45101
45102
45103 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
45104 PyObject *resultobj = NULL;
45105 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45106 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
45107 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
45108 bool result;
45109 PyObject * obj0 = 0 ;
45110 PyObject * obj1 = 0 ;
45111 PyObject * obj2 = 0 ;
45112 char *kwnames[] = {
45113 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
45114 };
45115
45116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
45117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45118 if (SWIG_arg_fail(1)) SWIG_fail;
45119 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45120 if (SWIG_arg_fail(2)) SWIG_fail;
45121 if (obj2) {
45122 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45123 if (SWIG_arg_fail(3)) SWIG_fail;
45124 }
45125 {
45126 PyThreadState* __tstate = wxPyBeginAllowThreads();
45127 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
45128
45129 wxPyEndAllowThreads(__tstate);
45130 if (PyErr_Occurred()) SWIG_fail;
45131 }
45132 {
45133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45134 }
45135 return resultobj;
45136 fail:
45137 return NULL;
45138 }
45139
45140
45141 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
45142 PyObject *resultobj = NULL;
45143 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
45144 wxGBPosition *arg2 = 0 ;
45145 wxGBSpan *arg3 = 0 ;
45146 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
45147 bool result;
45148 wxGBPosition temp2 ;
45149 wxGBSpan temp3 ;
45150 PyObject * obj0 = 0 ;
45151 PyObject * obj1 = 0 ;
45152 PyObject * obj2 = 0 ;
45153 PyObject * obj3 = 0 ;
45154 char *kwnames[] = {
45155 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
45156 };
45157
45158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
45160 if (SWIG_arg_fail(1)) SWIG_fail;
45161 {
45162 arg2 = &temp2;
45163 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
45164 }
45165 {
45166 arg3 = &temp3;
45167 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
45168 }
45169 if (obj3) {
45170 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
45171 if (SWIG_arg_fail(4)) SWIG_fail;
45172 }
45173 {
45174 PyThreadState* __tstate = wxPyBeginAllowThreads();
45175 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
45176
45177 wxPyEndAllowThreads(__tstate);
45178 if (PyErr_Occurred()) SWIG_fail;
45179 }
45180 {
45181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45182 }
45183 return resultobj;
45184 fail:
45185 return NULL;
45186 }
45187
45188
45189 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
45190 PyObject *obj;
45191 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45192 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
45193 Py_INCREF(obj);
45194 return Py_BuildValue((char *)"");
45195 }
45196 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
45197 PyObject *resultobj = NULL;
45198 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45199 wxRelationship arg2 ;
45200 wxWindow *arg3 = (wxWindow *) 0 ;
45201 wxEdge arg4 ;
45202 int arg5 = (int) 0 ;
45203 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
45204 PyObject * obj0 = 0 ;
45205 PyObject * obj1 = 0 ;
45206 PyObject * obj2 = 0 ;
45207 PyObject * obj3 = 0 ;
45208 PyObject * obj4 = 0 ;
45209 PyObject * obj5 = 0 ;
45210 char *kwnames[] = {
45211 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
45212 };
45213
45214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
45215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45216 if (SWIG_arg_fail(1)) SWIG_fail;
45217 {
45218 arg2 = static_cast<wxRelationship >(SWIG_As_int(obj1));
45219 if (SWIG_arg_fail(2)) SWIG_fail;
45220 }
45221 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45222 if (SWIG_arg_fail(3)) SWIG_fail;
45223 {
45224 arg4 = static_cast<wxEdge >(SWIG_As_int(obj3));
45225 if (SWIG_arg_fail(4)) SWIG_fail;
45226 }
45227 if (obj4) {
45228 {
45229 arg5 = static_cast<int >(SWIG_As_int(obj4));
45230 if (SWIG_arg_fail(5)) SWIG_fail;
45231 }
45232 }
45233 if (obj5) {
45234 {
45235 arg6 = static_cast<int >(SWIG_As_int(obj5));
45236 if (SWIG_arg_fail(6)) SWIG_fail;
45237 }
45238 }
45239 {
45240 PyThreadState* __tstate = wxPyBeginAllowThreads();
45241 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
45242
45243 wxPyEndAllowThreads(__tstate);
45244 if (PyErr_Occurred()) SWIG_fail;
45245 }
45246 Py_INCREF(Py_None); resultobj = Py_None;
45247 return resultobj;
45248 fail:
45249 return NULL;
45250 }
45251
45252
45253 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
45254 PyObject *resultobj = NULL;
45255 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45256 wxWindow *arg2 = (wxWindow *) 0 ;
45257 int arg3 = (int) 0 ;
45258 PyObject * obj0 = 0 ;
45259 PyObject * obj1 = 0 ;
45260 PyObject * obj2 = 0 ;
45261 char *kwnames[] = {
45262 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45263 };
45264
45265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
45266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45267 if (SWIG_arg_fail(1)) SWIG_fail;
45268 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45269 if (SWIG_arg_fail(2)) SWIG_fail;
45270 if (obj2) {
45271 {
45272 arg3 = static_cast<int >(SWIG_As_int(obj2));
45273 if (SWIG_arg_fail(3)) SWIG_fail;
45274 }
45275 }
45276 {
45277 PyThreadState* __tstate = wxPyBeginAllowThreads();
45278 (arg1)->LeftOf(arg2,arg3);
45279
45280 wxPyEndAllowThreads(__tstate);
45281 if (PyErr_Occurred()) SWIG_fail;
45282 }
45283 Py_INCREF(Py_None); resultobj = Py_None;
45284 return resultobj;
45285 fail:
45286 return NULL;
45287 }
45288
45289
45290 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
45291 PyObject *resultobj = NULL;
45292 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45293 wxWindow *arg2 = (wxWindow *) 0 ;
45294 int arg3 = (int) 0 ;
45295 PyObject * obj0 = 0 ;
45296 PyObject * obj1 = 0 ;
45297 PyObject * obj2 = 0 ;
45298 char *kwnames[] = {
45299 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45300 };
45301
45302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
45303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45304 if (SWIG_arg_fail(1)) SWIG_fail;
45305 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45306 if (SWIG_arg_fail(2)) SWIG_fail;
45307 if (obj2) {
45308 {
45309 arg3 = static_cast<int >(SWIG_As_int(obj2));
45310 if (SWIG_arg_fail(3)) SWIG_fail;
45311 }
45312 }
45313 {
45314 PyThreadState* __tstate = wxPyBeginAllowThreads();
45315 (arg1)->RightOf(arg2,arg3);
45316
45317 wxPyEndAllowThreads(__tstate);
45318 if (PyErr_Occurred()) SWIG_fail;
45319 }
45320 Py_INCREF(Py_None); resultobj = Py_None;
45321 return resultobj;
45322 fail:
45323 return NULL;
45324 }
45325
45326
45327 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
45328 PyObject *resultobj = NULL;
45329 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45330 wxWindow *arg2 = (wxWindow *) 0 ;
45331 int arg3 = (int) 0 ;
45332 PyObject * obj0 = 0 ;
45333 PyObject * obj1 = 0 ;
45334 PyObject * obj2 = 0 ;
45335 char *kwnames[] = {
45336 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45337 };
45338
45339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
45340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45341 if (SWIG_arg_fail(1)) SWIG_fail;
45342 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45343 if (SWIG_arg_fail(2)) SWIG_fail;
45344 if (obj2) {
45345 {
45346 arg3 = static_cast<int >(SWIG_As_int(obj2));
45347 if (SWIG_arg_fail(3)) SWIG_fail;
45348 }
45349 }
45350 {
45351 PyThreadState* __tstate = wxPyBeginAllowThreads();
45352 (arg1)->Above(arg2,arg3);
45353
45354 wxPyEndAllowThreads(__tstate);
45355 if (PyErr_Occurred()) SWIG_fail;
45356 }
45357 Py_INCREF(Py_None); resultobj = Py_None;
45358 return resultobj;
45359 fail:
45360 return NULL;
45361 }
45362
45363
45364 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
45365 PyObject *resultobj = NULL;
45366 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45367 wxWindow *arg2 = (wxWindow *) 0 ;
45368 int arg3 = (int) 0 ;
45369 PyObject * obj0 = 0 ;
45370 PyObject * obj1 = 0 ;
45371 PyObject * obj2 = 0 ;
45372 char *kwnames[] = {
45373 (char *) "self",(char *) "sibling",(char *) "marg", NULL
45374 };
45375
45376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
45377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45378 if (SWIG_arg_fail(1)) SWIG_fail;
45379 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45380 if (SWIG_arg_fail(2)) SWIG_fail;
45381 if (obj2) {
45382 {
45383 arg3 = static_cast<int >(SWIG_As_int(obj2));
45384 if (SWIG_arg_fail(3)) SWIG_fail;
45385 }
45386 }
45387 {
45388 PyThreadState* __tstate = wxPyBeginAllowThreads();
45389 (arg1)->Below(arg2,arg3);
45390
45391 wxPyEndAllowThreads(__tstate);
45392 if (PyErr_Occurred()) SWIG_fail;
45393 }
45394 Py_INCREF(Py_None); resultobj = Py_None;
45395 return resultobj;
45396 fail:
45397 return NULL;
45398 }
45399
45400
45401 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
45402 PyObject *resultobj = NULL;
45403 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45404 wxWindow *arg2 = (wxWindow *) 0 ;
45405 wxEdge arg3 ;
45406 int arg4 = (int) 0 ;
45407 PyObject * obj0 = 0 ;
45408 PyObject * obj1 = 0 ;
45409 PyObject * obj2 = 0 ;
45410 PyObject * obj3 = 0 ;
45411 char *kwnames[] = {
45412 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
45413 };
45414
45415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45417 if (SWIG_arg_fail(1)) SWIG_fail;
45418 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45419 if (SWIG_arg_fail(2)) SWIG_fail;
45420 {
45421 arg3 = static_cast<wxEdge >(SWIG_As_int(obj2));
45422 if (SWIG_arg_fail(3)) SWIG_fail;
45423 }
45424 if (obj3) {
45425 {
45426 arg4 = static_cast<int >(SWIG_As_int(obj3));
45427 if (SWIG_arg_fail(4)) SWIG_fail;
45428 }
45429 }
45430 {
45431 PyThreadState* __tstate = wxPyBeginAllowThreads();
45432 (arg1)->SameAs(arg2,arg3,arg4);
45433
45434 wxPyEndAllowThreads(__tstate);
45435 if (PyErr_Occurred()) SWIG_fail;
45436 }
45437 Py_INCREF(Py_None); resultobj = Py_None;
45438 return resultobj;
45439 fail:
45440 return NULL;
45441 }
45442
45443
45444 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
45445 PyObject *resultobj = NULL;
45446 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45447 wxWindow *arg2 = (wxWindow *) 0 ;
45448 wxEdge arg3 ;
45449 int arg4 ;
45450 PyObject * obj0 = 0 ;
45451 PyObject * obj1 = 0 ;
45452 PyObject * obj2 = 0 ;
45453 PyObject * obj3 = 0 ;
45454 char *kwnames[] = {
45455 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
45456 };
45457
45458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45460 if (SWIG_arg_fail(1)) SWIG_fail;
45461 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45462 if (SWIG_arg_fail(2)) SWIG_fail;
45463 {
45464 arg3 = static_cast<wxEdge >(SWIG_As_int(obj2));
45465 if (SWIG_arg_fail(3)) SWIG_fail;
45466 }
45467 {
45468 arg4 = static_cast<int >(SWIG_As_int(obj3));
45469 if (SWIG_arg_fail(4)) SWIG_fail;
45470 }
45471 {
45472 PyThreadState* __tstate = wxPyBeginAllowThreads();
45473 (arg1)->PercentOf(arg2,arg3,arg4);
45474
45475 wxPyEndAllowThreads(__tstate);
45476 if (PyErr_Occurred()) SWIG_fail;
45477 }
45478 Py_INCREF(Py_None); resultobj = Py_None;
45479 return resultobj;
45480 fail:
45481 return NULL;
45482 }
45483
45484
45485 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
45486 PyObject *resultobj = NULL;
45487 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45488 int arg2 ;
45489 PyObject * obj0 = 0 ;
45490 PyObject * obj1 = 0 ;
45491 char *kwnames[] = {
45492 (char *) "self",(char *) "val", NULL
45493 };
45494
45495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
45496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45497 if (SWIG_arg_fail(1)) SWIG_fail;
45498 {
45499 arg2 = static_cast<int >(SWIG_As_int(obj1));
45500 if (SWIG_arg_fail(2)) SWIG_fail;
45501 }
45502 {
45503 PyThreadState* __tstate = wxPyBeginAllowThreads();
45504 (arg1)->Absolute(arg2);
45505
45506 wxPyEndAllowThreads(__tstate);
45507 if (PyErr_Occurred()) SWIG_fail;
45508 }
45509 Py_INCREF(Py_None); resultobj = Py_None;
45510 return resultobj;
45511 fail:
45512 return NULL;
45513 }
45514
45515
45516 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
45517 PyObject *resultobj = NULL;
45518 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45519 PyObject * obj0 = 0 ;
45520 char *kwnames[] = {
45521 (char *) "self", NULL
45522 };
45523
45524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
45525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45526 if (SWIG_arg_fail(1)) SWIG_fail;
45527 {
45528 PyThreadState* __tstate = wxPyBeginAllowThreads();
45529 (arg1)->Unconstrained();
45530
45531 wxPyEndAllowThreads(__tstate);
45532 if (PyErr_Occurred()) SWIG_fail;
45533 }
45534 Py_INCREF(Py_None); resultobj = Py_None;
45535 return resultobj;
45536 fail:
45537 return NULL;
45538 }
45539
45540
45541 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
45542 PyObject *resultobj = NULL;
45543 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45544 PyObject * obj0 = 0 ;
45545 char *kwnames[] = {
45546 (char *) "self", NULL
45547 };
45548
45549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
45550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45551 if (SWIG_arg_fail(1)) SWIG_fail;
45552 {
45553 PyThreadState* __tstate = wxPyBeginAllowThreads();
45554 (arg1)->AsIs();
45555
45556 wxPyEndAllowThreads(__tstate);
45557 if (PyErr_Occurred()) SWIG_fail;
45558 }
45559 Py_INCREF(Py_None); resultobj = Py_None;
45560 return resultobj;
45561 fail:
45562 return NULL;
45563 }
45564
45565
45566 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
45567 PyObject *resultobj = NULL;
45568 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45569 wxWindow *result;
45570 PyObject * obj0 = 0 ;
45571 char *kwnames[] = {
45572 (char *) "self", NULL
45573 };
45574
45575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
45576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45577 if (SWIG_arg_fail(1)) SWIG_fail;
45578 {
45579 PyThreadState* __tstate = wxPyBeginAllowThreads();
45580 result = (wxWindow *)(arg1)->GetOtherWindow();
45581
45582 wxPyEndAllowThreads(__tstate);
45583 if (PyErr_Occurred()) SWIG_fail;
45584 }
45585 {
45586 resultobj = wxPyMake_wxObject(result, 0);
45587 }
45588 return resultobj;
45589 fail:
45590 return NULL;
45591 }
45592
45593
45594 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45595 PyObject *resultobj = NULL;
45596 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45597 wxEdge result;
45598 PyObject * obj0 = 0 ;
45599 char *kwnames[] = {
45600 (char *) "self", NULL
45601 };
45602
45603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
45604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45605 if (SWIG_arg_fail(1)) SWIG_fail;
45606 {
45607 PyThreadState* __tstate = wxPyBeginAllowThreads();
45608 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
45609
45610 wxPyEndAllowThreads(__tstate);
45611 if (PyErr_Occurred()) SWIG_fail;
45612 }
45613 resultobj = SWIG_From_int((result));
45614 return resultobj;
45615 fail:
45616 return NULL;
45617 }
45618
45619
45620 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45621 PyObject *resultobj = NULL;
45622 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45623 wxEdge arg2 ;
45624 PyObject * obj0 = 0 ;
45625 PyObject * obj1 = 0 ;
45626 char *kwnames[] = {
45627 (char *) "self",(char *) "which", NULL
45628 };
45629
45630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
45631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45632 if (SWIG_arg_fail(1)) SWIG_fail;
45633 {
45634 arg2 = static_cast<wxEdge >(SWIG_As_int(obj1));
45635 if (SWIG_arg_fail(2)) SWIG_fail;
45636 }
45637 {
45638 PyThreadState* __tstate = wxPyBeginAllowThreads();
45639 (arg1)->SetEdge(arg2);
45640
45641 wxPyEndAllowThreads(__tstate);
45642 if (PyErr_Occurred()) SWIG_fail;
45643 }
45644 Py_INCREF(Py_None); resultobj = Py_None;
45645 return resultobj;
45646 fail:
45647 return NULL;
45648 }
45649
45650
45651 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45652 PyObject *resultobj = NULL;
45653 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45654 int arg2 ;
45655 PyObject * obj0 = 0 ;
45656 PyObject * obj1 = 0 ;
45657 char *kwnames[] = {
45658 (char *) "self",(char *) "v", NULL
45659 };
45660
45661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
45662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45663 if (SWIG_arg_fail(1)) SWIG_fail;
45664 {
45665 arg2 = static_cast<int >(SWIG_As_int(obj1));
45666 if (SWIG_arg_fail(2)) SWIG_fail;
45667 }
45668 {
45669 PyThreadState* __tstate = wxPyBeginAllowThreads();
45670 (arg1)->SetValue(arg2);
45671
45672 wxPyEndAllowThreads(__tstate);
45673 if (PyErr_Occurred()) SWIG_fail;
45674 }
45675 Py_INCREF(Py_None); resultobj = Py_None;
45676 return resultobj;
45677 fail:
45678 return NULL;
45679 }
45680
45681
45682 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45683 PyObject *resultobj = NULL;
45684 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45685 int result;
45686 PyObject * obj0 = 0 ;
45687 char *kwnames[] = {
45688 (char *) "self", NULL
45689 };
45690
45691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
45692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45693 if (SWIG_arg_fail(1)) SWIG_fail;
45694 {
45695 PyThreadState* __tstate = wxPyBeginAllowThreads();
45696 result = (int)(arg1)->GetMargin();
45697
45698 wxPyEndAllowThreads(__tstate);
45699 if (PyErr_Occurred()) SWIG_fail;
45700 }
45701 {
45702 resultobj = SWIG_From_int(static_cast<int >(result));
45703 }
45704 return resultobj;
45705 fail:
45706 return NULL;
45707 }
45708
45709
45710 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45711 PyObject *resultobj = NULL;
45712 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45713 int arg2 ;
45714 PyObject * obj0 = 0 ;
45715 PyObject * obj1 = 0 ;
45716 char *kwnames[] = {
45717 (char *) "self",(char *) "m", NULL
45718 };
45719
45720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
45721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45722 if (SWIG_arg_fail(1)) SWIG_fail;
45723 {
45724 arg2 = static_cast<int >(SWIG_As_int(obj1));
45725 if (SWIG_arg_fail(2)) SWIG_fail;
45726 }
45727 {
45728 PyThreadState* __tstate = wxPyBeginAllowThreads();
45729 (arg1)->SetMargin(arg2);
45730
45731 wxPyEndAllowThreads(__tstate);
45732 if (PyErr_Occurred()) SWIG_fail;
45733 }
45734 Py_INCREF(Py_None); resultobj = Py_None;
45735 return resultobj;
45736 fail:
45737 return NULL;
45738 }
45739
45740
45741 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45742 PyObject *resultobj = NULL;
45743 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45744 int result;
45745 PyObject * obj0 = 0 ;
45746 char *kwnames[] = {
45747 (char *) "self", NULL
45748 };
45749
45750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
45751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45752 if (SWIG_arg_fail(1)) SWIG_fail;
45753 {
45754 PyThreadState* __tstate = wxPyBeginAllowThreads();
45755 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
45756
45757 wxPyEndAllowThreads(__tstate);
45758 if (PyErr_Occurred()) SWIG_fail;
45759 }
45760 {
45761 resultobj = SWIG_From_int(static_cast<int >(result));
45762 }
45763 return resultobj;
45764 fail:
45765 return NULL;
45766 }
45767
45768
45769 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
45770 PyObject *resultobj = NULL;
45771 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45772 int result;
45773 PyObject * obj0 = 0 ;
45774 char *kwnames[] = {
45775 (char *) "self", NULL
45776 };
45777
45778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
45779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45780 if (SWIG_arg_fail(1)) SWIG_fail;
45781 {
45782 PyThreadState* __tstate = wxPyBeginAllowThreads();
45783 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
45784
45785 wxPyEndAllowThreads(__tstate);
45786 if (PyErr_Occurred()) SWIG_fail;
45787 }
45788 {
45789 resultobj = SWIG_From_int(static_cast<int >(result));
45790 }
45791 return resultobj;
45792 fail:
45793 return NULL;
45794 }
45795
45796
45797 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45798 PyObject *resultobj = NULL;
45799 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45800 int result;
45801 PyObject * obj0 = 0 ;
45802 char *kwnames[] = {
45803 (char *) "self", NULL
45804 };
45805
45806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
45807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45808 if (SWIG_arg_fail(1)) SWIG_fail;
45809 {
45810 PyThreadState* __tstate = wxPyBeginAllowThreads();
45811 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
45812
45813 wxPyEndAllowThreads(__tstate);
45814 if (PyErr_Occurred()) SWIG_fail;
45815 }
45816 {
45817 resultobj = SWIG_From_int(static_cast<int >(result));
45818 }
45819 return resultobj;
45820 fail:
45821 return NULL;
45822 }
45823
45824
45825 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45826 PyObject *resultobj = NULL;
45827 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45828 bool result;
45829 PyObject * obj0 = 0 ;
45830 char *kwnames[] = {
45831 (char *) "self", NULL
45832 };
45833
45834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
45835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45836 if (SWIG_arg_fail(1)) SWIG_fail;
45837 {
45838 PyThreadState* __tstate = wxPyBeginAllowThreads();
45839 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
45840
45841 wxPyEndAllowThreads(__tstate);
45842 if (PyErr_Occurred()) SWIG_fail;
45843 }
45844 {
45845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45846 }
45847 return resultobj;
45848 fail:
45849 return NULL;
45850 }
45851
45852
45853 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45854 PyObject *resultobj = NULL;
45855 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45856 bool arg2 ;
45857 PyObject * obj0 = 0 ;
45858 PyObject * obj1 = 0 ;
45859 char *kwnames[] = {
45860 (char *) "self",(char *) "d", NULL
45861 };
45862
45863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
45864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45865 if (SWIG_arg_fail(1)) SWIG_fail;
45866 {
45867 arg2 = static_cast<bool >(SWIG_As_bool(obj1));
45868 if (SWIG_arg_fail(2)) SWIG_fail;
45869 }
45870 {
45871 PyThreadState* __tstate = wxPyBeginAllowThreads();
45872 (arg1)->SetDone(arg2);
45873
45874 wxPyEndAllowThreads(__tstate);
45875 if (PyErr_Occurred()) SWIG_fail;
45876 }
45877 Py_INCREF(Py_None); resultobj = Py_None;
45878 return resultobj;
45879 fail:
45880 return NULL;
45881 }
45882
45883
45884 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45885 PyObject *resultobj = NULL;
45886 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45887 wxRelationship result;
45888 PyObject * obj0 = 0 ;
45889 char *kwnames[] = {
45890 (char *) "self", NULL
45891 };
45892
45893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
45894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45895 if (SWIG_arg_fail(1)) SWIG_fail;
45896 {
45897 PyThreadState* __tstate = wxPyBeginAllowThreads();
45898 result = (wxRelationship)(arg1)->GetRelationship();
45899
45900 wxPyEndAllowThreads(__tstate);
45901 if (PyErr_Occurred()) SWIG_fail;
45902 }
45903 resultobj = SWIG_From_int((result));
45904 return resultobj;
45905 fail:
45906 return NULL;
45907 }
45908
45909
45910 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45911 PyObject *resultobj = NULL;
45912 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45913 wxRelationship arg2 ;
45914 PyObject * obj0 = 0 ;
45915 PyObject * obj1 = 0 ;
45916 char *kwnames[] = {
45917 (char *) "self",(char *) "r", NULL
45918 };
45919
45920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
45921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45922 if (SWIG_arg_fail(1)) SWIG_fail;
45923 {
45924 arg2 = static_cast<wxRelationship >(SWIG_As_int(obj1));
45925 if (SWIG_arg_fail(2)) SWIG_fail;
45926 }
45927 {
45928 PyThreadState* __tstate = wxPyBeginAllowThreads();
45929 (arg1)->SetRelationship(arg2);
45930
45931 wxPyEndAllowThreads(__tstate);
45932 if (PyErr_Occurred()) SWIG_fail;
45933 }
45934 Py_INCREF(Py_None); resultobj = Py_None;
45935 return resultobj;
45936 fail:
45937 return NULL;
45938 }
45939
45940
45941 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
45942 PyObject *resultobj = NULL;
45943 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45944 wxWindow *arg2 = (wxWindow *) 0 ;
45945 bool result;
45946 PyObject * obj0 = 0 ;
45947 PyObject * obj1 = 0 ;
45948 char *kwnames[] = {
45949 (char *) "self",(char *) "otherW", NULL
45950 };
45951
45952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
45953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45954 if (SWIG_arg_fail(1)) SWIG_fail;
45955 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45956 if (SWIG_arg_fail(2)) SWIG_fail;
45957 {
45958 PyThreadState* __tstate = wxPyBeginAllowThreads();
45959 result = (bool)(arg1)->ResetIfWin(arg2);
45960
45961 wxPyEndAllowThreads(__tstate);
45962 if (PyErr_Occurred()) SWIG_fail;
45963 }
45964 {
45965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45966 }
45967 return resultobj;
45968 fail:
45969 return NULL;
45970 }
45971
45972
45973 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
45974 PyObject *resultobj = NULL;
45975 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45976 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
45977 wxWindow *arg3 = (wxWindow *) 0 ;
45978 bool result;
45979 PyObject * obj0 = 0 ;
45980 PyObject * obj1 = 0 ;
45981 PyObject * obj2 = 0 ;
45982 char *kwnames[] = {
45983 (char *) "self",(char *) "constraints",(char *) "win", NULL
45984 };
45985
45986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
45987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45988 if (SWIG_arg_fail(1)) SWIG_fail;
45989 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45990 if (SWIG_arg_fail(2)) SWIG_fail;
45991 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45992 if (SWIG_arg_fail(3)) SWIG_fail;
45993 {
45994 PyThreadState* __tstate = wxPyBeginAllowThreads();
45995 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
45996
45997 wxPyEndAllowThreads(__tstate);
45998 if (PyErr_Occurred()) SWIG_fail;
45999 }
46000 {
46001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46002 }
46003 return resultobj;
46004 fail:
46005 return NULL;
46006 }
46007
46008
46009 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
46010 PyObject *resultobj = NULL;
46011 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
46012 wxEdge arg2 ;
46013 wxWindow *arg3 = (wxWindow *) 0 ;
46014 wxWindow *arg4 = (wxWindow *) 0 ;
46015 int result;
46016 PyObject * obj0 = 0 ;
46017 PyObject * obj1 = 0 ;
46018 PyObject * obj2 = 0 ;
46019 PyObject * obj3 = 0 ;
46020 char *kwnames[] = {
46021 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
46022 };
46023
46024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
46025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
46026 if (SWIG_arg_fail(1)) SWIG_fail;
46027 {
46028 arg2 = static_cast<wxEdge >(SWIG_As_int(obj1));
46029 if (SWIG_arg_fail(2)) SWIG_fail;
46030 }
46031 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46032 if (SWIG_arg_fail(3)) SWIG_fail;
46033 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46034 if (SWIG_arg_fail(4)) SWIG_fail;
46035 {
46036 PyThreadState* __tstate = wxPyBeginAllowThreads();
46037 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
46038
46039 wxPyEndAllowThreads(__tstate);
46040 if (PyErr_Occurred()) SWIG_fail;
46041 }
46042 {
46043 resultobj = SWIG_From_int(static_cast<int >(result));
46044 }
46045 return resultobj;
46046 fail:
46047 return NULL;
46048 }
46049
46050
46051 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
46052 PyObject *obj;
46053 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
46054 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
46055 Py_INCREF(obj);
46056 return Py_BuildValue((char *)"");
46057 }
46058 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
46059 PyObject *resultobj = NULL;
46060 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46061 wxIndividualLayoutConstraint *result;
46062 PyObject * obj0 = 0 ;
46063 char *kwnames[] = {
46064 (char *) "self", NULL
46065 };
46066
46067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
46068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46069 if (SWIG_arg_fail(1)) SWIG_fail;
46070 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
46071
46072 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46073 return resultobj;
46074 fail:
46075 return NULL;
46076 }
46077
46078
46079 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
46080 PyObject *resultobj = NULL;
46081 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46082 wxIndividualLayoutConstraint *result;
46083 PyObject * obj0 = 0 ;
46084 char *kwnames[] = {
46085 (char *) "self", NULL
46086 };
46087
46088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
46089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46090 if (SWIG_arg_fail(1)) SWIG_fail;
46091 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
46092
46093 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46094 return resultobj;
46095 fail:
46096 return NULL;
46097 }
46098
46099
46100 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
46101 PyObject *resultobj = NULL;
46102 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46103 wxIndividualLayoutConstraint *result;
46104 PyObject * obj0 = 0 ;
46105 char *kwnames[] = {
46106 (char *) "self", NULL
46107 };
46108
46109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
46110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46111 if (SWIG_arg_fail(1)) SWIG_fail;
46112 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
46113
46114 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46115 return resultobj;
46116 fail:
46117 return NULL;
46118 }
46119
46120
46121 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
46122 PyObject *resultobj = NULL;
46123 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46124 wxIndividualLayoutConstraint *result;
46125 PyObject * obj0 = 0 ;
46126 char *kwnames[] = {
46127 (char *) "self", NULL
46128 };
46129
46130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
46131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46132 if (SWIG_arg_fail(1)) SWIG_fail;
46133 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
46134
46135 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46136 return resultobj;
46137 fail:
46138 return NULL;
46139 }
46140
46141
46142 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
46143 PyObject *resultobj = NULL;
46144 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46145 wxIndividualLayoutConstraint *result;
46146 PyObject * obj0 = 0 ;
46147 char *kwnames[] = {
46148 (char *) "self", NULL
46149 };
46150
46151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
46152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46153 if (SWIG_arg_fail(1)) SWIG_fail;
46154 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
46155
46156 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46157 return resultobj;
46158 fail:
46159 return NULL;
46160 }
46161
46162
46163 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
46164 PyObject *resultobj = NULL;
46165 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46166 wxIndividualLayoutConstraint *result;
46167 PyObject * obj0 = 0 ;
46168 char *kwnames[] = {
46169 (char *) "self", NULL
46170 };
46171
46172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
46173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46174 if (SWIG_arg_fail(1)) SWIG_fail;
46175 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
46176
46177 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46178 return resultobj;
46179 fail:
46180 return NULL;
46181 }
46182
46183
46184 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
46185 PyObject *resultobj = NULL;
46186 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46187 wxIndividualLayoutConstraint *result;
46188 PyObject * obj0 = 0 ;
46189 char *kwnames[] = {
46190 (char *) "self", NULL
46191 };
46192
46193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
46194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46195 if (SWIG_arg_fail(1)) SWIG_fail;
46196 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
46197
46198 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46199 return resultobj;
46200 fail:
46201 return NULL;
46202 }
46203
46204
46205 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
46206 PyObject *resultobj = NULL;
46207 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46208 wxIndividualLayoutConstraint *result;
46209 PyObject * obj0 = 0 ;
46210 char *kwnames[] = {
46211 (char *) "self", NULL
46212 };
46213
46214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
46215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46216 if (SWIG_arg_fail(1)) SWIG_fail;
46217 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
46218
46219 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
46220 return resultobj;
46221 fail:
46222 return NULL;
46223 }
46224
46225
46226 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
46227 PyObject *resultobj = NULL;
46228 wxLayoutConstraints *result;
46229 char *kwnames[] = {
46230 NULL
46231 };
46232
46233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
46234 {
46235 PyThreadState* __tstate = wxPyBeginAllowThreads();
46236 result = (wxLayoutConstraints *)new wxLayoutConstraints();
46237
46238 wxPyEndAllowThreads(__tstate);
46239 if (PyErr_Occurred()) SWIG_fail;
46240 }
46241 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
46242 return resultobj;
46243 fail:
46244 return NULL;
46245 }
46246
46247
46248 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
46249 PyObject *resultobj = NULL;
46250 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46251 wxWindow *arg2 = (wxWindow *) 0 ;
46252 int *arg3 = (int *) 0 ;
46253 bool result;
46254 int temp3 ;
46255 int res3 = 0 ;
46256 PyObject * obj0 = 0 ;
46257 PyObject * obj1 = 0 ;
46258 char *kwnames[] = {
46259 (char *) "self",(char *) "win", NULL
46260 };
46261
46262 arg3 = &temp3; res3 = SWIG_NEWOBJ;
46263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
46264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46265 if (SWIG_arg_fail(1)) SWIG_fail;
46266 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
46267 if (SWIG_arg_fail(2)) SWIG_fail;
46268 {
46269 PyThreadState* __tstate = wxPyBeginAllowThreads();
46270 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
46271
46272 wxPyEndAllowThreads(__tstate);
46273 if (PyErr_Occurred()) SWIG_fail;
46274 }
46275 {
46276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46277 }
46278 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
46279 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
46280 return resultobj;
46281 fail:
46282 return NULL;
46283 }
46284
46285
46286 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
46287 PyObject *resultobj = NULL;
46288 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
46289 bool result;
46290 PyObject * obj0 = 0 ;
46291 char *kwnames[] = {
46292 (char *) "self", NULL
46293 };
46294
46295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
46296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
46297 if (SWIG_arg_fail(1)) SWIG_fail;
46298 {
46299 PyThreadState* __tstate = wxPyBeginAllowThreads();
46300 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
46301
46302 wxPyEndAllowThreads(__tstate);
46303 if (PyErr_Occurred()) SWIG_fail;
46304 }
46305 {
46306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46307 }
46308 return resultobj;
46309 fail:
46310 return NULL;
46311 }
46312
46313
46314 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
46315 PyObject *obj;
46316 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
46317 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
46318 Py_INCREF(obj);
46319 return Py_BuildValue((char *)"");
46320 }
46321 static PyMethodDef SwigMethods[] = {
46322 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
46323 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
46324 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
46327 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
46348 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
46361 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
46376 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
46430 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
46458 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
46477 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
46479 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
46487 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
46488 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
46500 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
46512 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
46516 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
46522 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
46532 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
46542 { (char *)"new_PyImageHandler", (PyCFunction) _wrap_new_PyImageHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
46545 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
46552 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"Image_RGBValue_red_set", (PyCFunction) _wrap_Image_RGBValue_red_set, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"Image_RGBValue_red_get", (PyCFunction) _wrap_Image_RGBValue_red_get, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"Image_RGBValue_green_set", (PyCFunction) _wrap_Image_RGBValue_green_set, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"Image_RGBValue_green_get", (PyCFunction) _wrap_Image_RGBValue_green_get, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"Image_RGBValue_blue_set", (PyCFunction) _wrap_Image_RGBValue_blue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"Image_RGBValue_blue_get", (PyCFunction) _wrap_Image_RGBValue_blue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
46560 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"Image_HSVValue_hue_set", (PyCFunction) _wrap_Image_HSVValue_hue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"Image_HSVValue_hue_get", (PyCFunction) _wrap_Image_HSVValue_hue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"Image_HSVValue_saturation_set", (PyCFunction) _wrap_Image_HSVValue_saturation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"Image_HSVValue_saturation_get", (PyCFunction) _wrap_Image_HSVValue_saturation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"Image_HSVValue_value_set", (PyCFunction) _wrap_Image_HSVValue_value_set, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"Image_HSVValue_value_get", (PyCFunction) _wrap_Image_HSVValue_value_get, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
46568 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46603 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46604 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46612 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46617 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46624 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46626 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
46634 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46636 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46638 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46639 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
46640 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46642 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46643 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46644 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46645 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
46646 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46647 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46648 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
46649 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
46650 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46651 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
46652 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46653 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
46654 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46655 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
46656 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46657 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
46658 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46659 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
46660 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46661 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
46662 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46663 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
46664 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46665 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
46666 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46667 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
46668 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46669 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
46670 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46671 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
46672 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46673 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
46674 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
46675 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
46676 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46677 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46678 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46679 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46680 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46681 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46682 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46683 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46684 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46685 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46686 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
46687 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
46688 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46689 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
46690 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46691 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
46692 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46693 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46694 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46695 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46696 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46697 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46698 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46699 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46700 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46701 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
46702 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
46703 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
46704 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46705 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46706 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46707 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
46708 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46709 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46710 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
46711 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46712 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46713 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
46714 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46715 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46716 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46717 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46718 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46719 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46720 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46721 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46722 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46723 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46724 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46725 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
46726 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46727 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46728 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
46729 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
46730 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
46731 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46732 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46733 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46734 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46735 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46736 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
46737 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46738 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46739 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46740 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46741 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46742 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
46743 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46744 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
46745 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
46746 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46747 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
46748 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
46749 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46750 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
46751 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46752 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46753 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46754 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46755 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46756 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46757 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
46758 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
46759 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
46760 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
46761 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
46762 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46763 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46764 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46765 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46766 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46767 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46768 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
46769 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
46770 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
46771 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
46772 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46773 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46774 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46775 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46776 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46777 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
46778 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
46779 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
46780 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
46781 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46782 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46783 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46784 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46785 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46786 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46787 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46788 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46789 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46790 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46791 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46792 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46793 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46794 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46795 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46796 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46797 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46798 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46799 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46800 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46801 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
46802 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
46803 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
46804 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
46805 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
46806 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46807 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46808 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46809 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46810 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46811 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46812 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
46813 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46814 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46815 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46816 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46817 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46818 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46819 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
46820 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46821 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46822 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46823 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46824 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46825 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46826 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46827 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46828 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46829 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46830 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46831 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46832 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46833 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46834 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46835 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46836 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46837 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46838 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46839 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46840 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46841 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46842 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46843 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46844 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46845 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46846 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
46847 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
46848 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
46849 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46850 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46851 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46852 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46853 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46854 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
46855 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
46856 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
46857 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
46858 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
46859 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46860 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46861 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46862 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46863 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46864 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
46865 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46866 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
46867 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46868 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
46869 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46870 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
46871 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
46872 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46873 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46874 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46875 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
46876 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46877 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46878 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
46879 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46880 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46881 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
46882 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46883 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
46884 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46885 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
46886 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
46887 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46888 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
46889 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46890 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46891 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46892 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46893 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46894 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46895 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46896 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
46897 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46898 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46899 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46900 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
46901 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46902 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
46903 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
46904 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46905 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
46906 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46907 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46908 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46909 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
46910 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46911 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46912 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46913 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46914 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
46915 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46916 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46917 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46918 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46919 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46920 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46921 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46922 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
46923 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
46924 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46925 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46926 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
46927 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46928 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
46929 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46930 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46931 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
46932 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46933 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
46934 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46935 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46936 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46937 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
46938 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46939 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46940 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46941 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
46942 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46943 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46944 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46945 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46946 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46947 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46948 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46949 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46950 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46951 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46952 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
46953 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46954 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46955 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
46956 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46957 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46958 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
46959 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46960 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46961 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46962 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
46963 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46964 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
46965 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
46966 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46967 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46968 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
46969 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
46970 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46971 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46972 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46973 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46974 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
46975 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46976 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46977 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46978 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46979 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
46980 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46981 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46982 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46983 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
46984 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46985 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46986 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46987 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46988 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46989 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46990 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46991 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46992 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46993 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
46994 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46995 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46996 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46997 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46998 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46999 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
47000 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
47001 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
47002 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
47003 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
47004 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
47005 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
47006 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47007 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47008 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
47009 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
47010 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
47011 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
47012 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
47013 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
47014 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
47015 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
47016 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
47017 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47018 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47019 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47020 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
47021 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
47022 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47023 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47024 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
47025 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
47026 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
47027 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
47028 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
47029 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
47030 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
47031 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
47032 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
47033 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
47034 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
47035 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
47036 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
47037 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
47038 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
47039 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
47040 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
47041 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
47042 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
47043 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
47044 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
47045 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
47046 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
47047 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
47048 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
47049 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
47050 { (char *)"delete_EventLoopActivator", (PyCFunction) _wrap_delete_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
47051 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
47052 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
47053 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
47054 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47055 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
47056 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
47057 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
47058 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
47059 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47060 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47061 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
47062 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
47063 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
47064 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47065 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47066 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
47067 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
47068 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
47069 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
47070 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
47071 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
47072 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
47073 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
47074 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47075 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
47076 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
47077 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
47078 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47079 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
47080 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47081 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47082 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
47083 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
47084 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
47085 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
47086 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
47087 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
47088 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
47089 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
47090 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
47091 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47092 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
47093 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47094 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
47095 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
47096 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
47097 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
47098 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
47099 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
47100 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
47101 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
47102 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47103 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47104 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47105 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47106 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47107 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47108 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
47109 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47110 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
47111 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47112 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47113 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47114 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47115 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47116 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
47117 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
47118 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
47119 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
47120 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
47121 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
47122 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
47123 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47124 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
47125 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47126 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
47127 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
47128 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47129 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47130 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
47131 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47132 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47133 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47134 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47135 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47136 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
47137 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47138 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
47139 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
47140 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47141 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
47142 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47143 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
47144 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47145 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47146 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47147 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47148 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47149 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
47150 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47151 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47152 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
47153 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47154 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47155 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47156 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
47157 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47158 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
47159 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
47160 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47161 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47162 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
47163 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
47164 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
47165 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
47166 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47167 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47168 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
47169 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
47170 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
47171 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
47172 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
47173 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
47174 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
47175 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47176 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47177 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47178 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47179 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47180 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47181 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47182 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
47183 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47184 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47185 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47186 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47187 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
47188 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
47189 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
47190 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
47191 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
47192 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
47193 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
47194 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47195 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
47196 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
47197 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
47198 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
47199 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
47200 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
47201 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
47202 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
47203 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
47204 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
47205 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
47206 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
47207 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
47208 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
47209 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
47210 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
47211 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47212 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
47213 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47214 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47215 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47216 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47217 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47218 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47219 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47220 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47221 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47222 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
47223 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47224 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47225 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
47226 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
47227 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
47228 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47229 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
47230 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47231 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
47232 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
47233 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
47234 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47235 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
47236 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
47237 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
47238 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
47239 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
47240 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
47241 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
47242 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
47243 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
47244 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
47245 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
47246 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47247 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47248 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47249 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
47250 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
47251 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
47252 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
47253 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
47254 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
47255 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
47256 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
47257 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47258 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
47259 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
47260 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
47261 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
47262 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
47263 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
47264 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
47265 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
47266 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
47267 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
47268 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
47269 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
47270 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
47271 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
47272 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
47273 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47274 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47275 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
47276 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
47277 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47278 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47279 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
47280 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47281 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47282 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47283 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47284 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
47285 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
47286 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
47287 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
47288 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47289 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
47290 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47291 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
47292 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
47293 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
47294 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47295 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47296 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47297 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47298 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
47299 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
47300 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
47301 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
47302 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47303 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
47304 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
47305 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47306 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47307 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47308 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47309 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47310 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
47311 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
47312 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47313 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47314 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47315 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47316 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47317 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47318 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47319 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47320 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47321 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
47322 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
47323 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47324 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47325 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
47326 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47327 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
47328 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
47329 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
47330 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
47331 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
47332 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
47333 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
47334 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
47335 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47336 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47337 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47338 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47339 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47340 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47341 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47342 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47343 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47344 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
47345 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
47346 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47347 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
47348 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47349 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47350 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
47351 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
47352 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
47353 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47354 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47355 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47356 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47357 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
47358 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
47359 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
47360 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47361 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47362 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
47363 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47364 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
47365 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47366 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
47367 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
47368 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
47369 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
47370 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47371 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
47372 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47373 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47374 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47375 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47376 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47377 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47378 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47379 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47380 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
47381 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
47382 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
47383 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
47384 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47385 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47386 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_GetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47387 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
47388 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
47389 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47390 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47391 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
47392 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
47393 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
47394 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
47395 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47396 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
47397 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
47398 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47399 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
47400 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47401 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
47402 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47403 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47404 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
47405 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
47406 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
47407 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
47408 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
47409 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
47410 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47411 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
47412 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47413 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
47414 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47415 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47416 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47417 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
47418 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47419 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
47420 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47421 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
47422 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
47423 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47424 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
47425 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47426 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47427 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
47428 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47429 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47430 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
47431 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
47432 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
47433 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
47434 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
47435 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
47436 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47437 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
47438 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
47439 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
47440 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
47441 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
47442 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47443 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47444 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
47445 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47446 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
47447 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
47448 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
47449 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
47450 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
47451 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
47452 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
47453 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47454 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47455 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47456 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47457 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
47458 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
47459 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
47460 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47461 { (char *)"delete_SizerItem", (PyCFunction) _wrap_delete_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47462 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47463 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47464 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47465 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47466 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47467 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47468 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47469 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47470 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47471 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47472 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
47473 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
47474 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
47475 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47476 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47477 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47478 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47479 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47480 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47481 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47482 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47483 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47484 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47485 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47486 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47487 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47488 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47489 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47490 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47491 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47492 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47493 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47494 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47495 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47496 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47497 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47498 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
47499 { (char *)"delete_Sizer", (PyCFunction) _wrap_delete_Sizer, METH_VARARGS | METH_KEYWORDS, NULL},
47500 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47501 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47502 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47503 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47504 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47505 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47506 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
47507 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47508 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47509 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47510 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47511 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47512 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47513 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47514 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47515 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47516 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
47517 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47518 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47519 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
47520 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
47521 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47522 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47523 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47524 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47525 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47526 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47527 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47528 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
47529 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
47530 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
47531 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47532 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
47533 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47534 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47535 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47536 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
47537 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47538 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
47539 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
47540 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47541 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47542 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47543 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47544 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47545 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47546 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47547 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47548 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47549 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
47550 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47551 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47552 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47553 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47554 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47555 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47556 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47557 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47558 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47559 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
47560 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
47561 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
47562 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47563 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
47564 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
47565 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47566 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47567 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47568 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47569 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
47570 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47571 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47572 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
47573 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
47574 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47575 { (char *)"delete_GBPosition", (PyCFunction) _wrap_delete_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47576 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47577 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47578 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47579 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47580 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47581 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47582 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47583 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47584 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
47585 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47586 { (char *)"delete_GBSpan", (PyCFunction) _wrap_delete_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47587 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47588 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47589 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47590 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47591 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47592 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47593 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47594 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47595 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
47596 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47597 { (char *)"delete_GBSizerItem", (PyCFunction) _wrap_delete_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47598 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47599 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47600 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47601 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47602 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47603 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47604 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47605 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
47606 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
47607 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
47608 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47609 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47610 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
47611 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47612 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47613 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47614 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47615 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47616 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47617 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
47618 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
47619 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
47620 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
47621 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
47622 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47623 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47624 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
47625 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
47626 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
47627 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47628 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
47629 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
47630 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
47631 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
47632 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
47633 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
47634 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
47635 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
47636 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
47637 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47638 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47639 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47640 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47641 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47642 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47643 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47644 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
47645 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47646 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47647 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47648 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47649 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47650 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
47651 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
47652 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47653 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
47654 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
47655 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
47656 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
47657 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
47658 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
47659 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
47660 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
47661 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
47662 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47663 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47664 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
47665 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
47666 { NULL, NULL, 0, NULL }
47667 };
47668
47669
47670 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
47671
47672 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
47673 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
47674 }
47675 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
47676 return (void *)((wxSizer *) ((wxBoxSizer *) x));
47677 }
47678 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
47679 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
47680 }
47681 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
47682 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47683 }
47684 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
47685 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47686 }
47687 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
47688 return (void *)((wxSizer *) ((wxGridSizer *) x));
47689 }
47690 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
47691 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
47692 }
47693 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
47694 return (void *)((wxSizer *) ((wxPySizer *) x));
47695 }
47696 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
47697 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
47698 }
47699 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
47700 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47701 }
47702 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
47703 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
47704 }
47705 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
47706 return (void *)((wxEvent *) ((wxMenuEvent *) x));
47707 }
47708 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
47709 return (void *)((wxEvent *) ((wxCloseEvent *) x));
47710 }
47711 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
47712 return (void *)((wxEvent *) ((wxMouseEvent *) x));
47713 }
47714 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
47715 return (void *)((wxEvent *) ((wxEraseEvent *) x));
47716 }
47717 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
47718 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
47719 }
47720 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
47721 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
47722 }
47723 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
47724 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
47725 }
47726 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
47727 return (void *)((wxEvent *) ((wxPyEvent *) x));
47728 }
47729 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
47730 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
47731 }
47732 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
47733 return (void *)((wxEvent *) ((wxIdleEvent *) x));
47734 }
47735 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
47736 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
47737 }
47738 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
47739 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
47740 }
47741 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
47742 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
47743 }
47744 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
47745 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
47746 }
47747 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
47748 return (void *)((wxEvent *) ((wxActivateEvent *) x));
47749 }
47750 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
47751 return (void *)((wxEvent *) ((wxSizeEvent *) x));
47752 }
47753 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
47754 return (void *)((wxEvent *) ((wxMoveEvent *) x));
47755 }
47756 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
47757 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
47758 }
47759 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
47760 return (void *)((wxEvent *) ((wxPaintEvent *) x));
47761 }
47762 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
47763 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
47764 }
47765 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
47766 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
47767 }
47768 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
47769 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
47770 }
47771 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
47772 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
47773 }
47774 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
47775 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47776 }
47777 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
47778 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
47779 }
47780 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
47781 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
47782 }
47783 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
47784 return (void *)((wxEvent *) ((wxFocusEvent *) x));
47785 }
47786 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
47787 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
47788 }
47789 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
47790 return (void *)((wxEvent *) ((wxShowEvent *) x));
47791 }
47792 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
47793 return (void *)((wxEvent *) ((wxCommandEvent *) x));
47794 }
47795 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
47796 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
47797 }
47798 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
47799 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47800 }
47801 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
47802 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
47803 }
47804 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
47805 return (void *)((wxEvent *) ((wxKeyEvent *) x));
47806 }
47807 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
47808 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
47809 }
47810 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
47811 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
47812 }
47813 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
47814 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
47815 }
47816 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
47817 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
47818 }
47819 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
47820 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
47821 }
47822 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
47823 return (void *)((wxControl *) ((wxControlWithItems *) x));
47824 }
47825 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
47826 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
47827 }
47828 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
47829 return (void *)((wxEvtHandler *) ((wxWindow *) x));
47830 }
47831 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
47832 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47833 }
47834 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
47835 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
47836 }
47837 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
47838 return (void *)((wxEvtHandler *) ((wxValidator *) x));
47839 }
47840 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
47841 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
47842 }
47843 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
47844 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
47845 }
47846 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
47847 return (void *)((wxEvtHandler *) ((wxMenu *) x));
47848 }
47849 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
47850 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
47851 }
47852 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
47853 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
47854 }
47855 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
47856 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
47857 }
47858 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
47859 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
47860 }
47861 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
47862 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
47863 }
47864 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
47865 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47866 }
47867 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
47868 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
47869 }
47870 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
47871 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
47872 }
47873 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
47874 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
47875 }
47876 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
47877 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47878 }
47879 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
47880 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47881 }
47882 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
47883 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
47884 }
47885 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
47886 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
47887 }
47888 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
47889 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
47890 }
47891 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
47892 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
47893 }
47894 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
47895 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
47896 }
47897 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
47898 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
47899 }
47900 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
47901 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
47902 }
47903 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
47904 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
47905 }
47906 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
47907 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
47908 }
47909 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
47910 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
47911 }
47912 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
47913 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
47914 }
47915 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
47916 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
47917 }
47918 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
47919 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
47920 }
47921 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
47922 return (void *)((wxObject *) ((wxSizerItem *) x));
47923 }
47924 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
47925 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
47926 }
47927 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
47928 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
47929 }
47930 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
47931 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
47932 }
47933 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
47934 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
47935 }
47936 static void *_p_wxSizerTo_p_wxObject(void *x) {
47937 return (void *)((wxObject *) ((wxSizer *) x));
47938 }
47939 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
47940 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47941 }
47942 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
47943 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
47944 }
47945 static void *_p_wxEventTo_p_wxObject(void *x) {
47946 return (void *)((wxObject *) ((wxEvent *) x));
47947 }
47948 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
47949 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
47950 }
47951 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
47952 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
47953 }
47954 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
47955 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
47956 }
47957 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
47958 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
47959 }
47960 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
47961 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
47962 }
47963 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
47964 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
47965 }
47966 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
47967 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
47968 }
47969 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
47970 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47971 }
47972 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
47973 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
47974 }
47975 static void *_p_wxControlTo_p_wxObject(void *x) {
47976 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
47977 }
47978 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
47979 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
47980 }
47981 static void *_p_wxFSFileTo_p_wxObject(void *x) {
47982 return (void *)((wxObject *) ((wxFSFile *) x));
47983 }
47984 static void *_p_wxPySizerTo_p_wxObject(void *x) {
47985 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
47986 }
47987 static void *_p_wxPyEventTo_p_wxObject(void *x) {
47988 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
47989 }
47990 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
47991 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
47992 }
47993 static void *_p_wxShowEventTo_p_wxObject(void *x) {
47994 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
47995 }
47996 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
47997 return (void *)((wxObject *) ((wxMenuItem *) x));
47998 }
47999 static void *_p_wxDateEventTo_p_wxObject(void *x) {
48000 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
48001 }
48002 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
48003 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
48004 }
48005 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
48006 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
48007 }
48008 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
48009 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
48010 }
48011 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
48012 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
48013 }
48014 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
48015 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
48016 }
48017 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
48018 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
48019 }
48020 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
48021 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
48022 }
48023 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
48024 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
48025 }
48026 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
48027 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
48028 }
48029 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
48030 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
48031 }
48032 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
48033 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
48034 }
48035 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
48036 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
48037 }
48038 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
48039 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
48040 }
48041 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
48042 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
48043 }
48044 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
48045 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
48046 }
48047 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
48048 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
48049 }
48050 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
48051 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
48052 }
48053 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
48054 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
48055 }
48056 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
48057 return (void *)((wxObject *) ((wxImageHandler *) x));
48058 }
48059 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
48060 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
48061 }
48062 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
48063 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
48064 }
48065 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
48066 return (void *)((wxObject *) ((wxEvtHandler *) x));
48067 }
48068 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
48069 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
48070 }
48071 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
48072 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
48073 }
48074 static void *_p_wxImageTo_p_wxObject(void *x) {
48075 return (void *)((wxObject *) ((wxImage *) x));
48076 }
48077 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
48078 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
48079 }
48080 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
48081 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
48082 }
48083 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
48084 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
48085 }
48086 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
48087 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
48088 }
48089 static void *_p_wxWindowTo_p_wxObject(void *x) {
48090 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
48091 }
48092 static void *_p_wxMenuTo_p_wxObject(void *x) {
48093 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
48094 }
48095 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
48096 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
48097 }
48098 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
48099 return (void *)((wxObject *) ((wxFileSystem *) x));
48100 }
48101 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
48102 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
48103 }
48104 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
48105 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
48106 }
48107 static void *_p_wxPyAppTo_p_wxObject(void *x) {
48108 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
48109 }
48110 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
48111 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
48112 }
48113 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
48114 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
48115 }
48116 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
48117 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
48118 }
48119 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
48120 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
48121 }
48122 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
48123 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
48124 }
48125 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
48126 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
48127 }
48128 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
48129 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
48130 }
48131 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
48132 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
48133 }
48134 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
48135 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
48136 }
48137 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
48138 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
48139 }
48140 static void *_p_wxValidatorTo_p_wxObject(void *x) {
48141 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
48142 }
48143 static void *_p_wxControlTo_p_wxWindow(void *x) {
48144 return (void *)((wxWindow *) ((wxControl *) x));
48145 }
48146 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
48147 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
48148 }
48149 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
48150 return (void *)((wxWindow *) ((wxMenuBar *) x));
48151 }
48152 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
48153 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
48154 }
48155 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
48156 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
48157 }
48158 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
48159 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
48160 }
48161 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
48162 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
48163 }
48164 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
48165 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
48166 }
48167 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
48168 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
48169 }
48170 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
48171 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
48172 }
48173 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
48174 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
48175 }
48176 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
48177 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
48178 }
48179 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
48180 return (void *)((wxValidator *) ((wxPyValidator *) x));
48181 }
48182 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, 0};
48183 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, 0};
48184 static swig_type_info _swigt__p_form_ops_t = {"_p_form_ops_t", "enum form_ops_t *|form_ops_t *", 0, 0, 0};
48185 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, 0};
48186 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, 0};
48187 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, 0};
48188 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, 0};
48189 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, 0};
48190 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, 0};
48191 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, 0};
48192 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, 0};
48193 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, 0};
48194 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, 0};
48195 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, 0};
48196 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, 0};
48197 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, 0};
48198 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, 0};
48199 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, 0};
48200 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, 0};
48201 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, 0};
48202 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, 0};
48203 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, 0};
48204 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, 0};
48205 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, 0};
48206 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, 0};
48207 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, 0};
48208 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, 0};
48209 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, 0};
48210 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, 0};
48211 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, 0};
48212 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, 0};
48213 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, 0};
48214 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, 0};
48215 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, 0};
48216 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, 0};
48217 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, 0};
48218 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, 0};
48219 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, 0};
48220 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, 0};
48221 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, 0};
48222 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, 0};
48223 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, 0};
48224 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, 0};
48225 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, 0};
48226 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, 0};
48227 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, 0};
48228 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, 0};
48229 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, 0};
48230 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, 0};
48231 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, 0};
48232 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, 0};
48233 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, 0};
48234 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, 0};
48235 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, 0};
48236 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, 0};
48237 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, 0};
48238 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, 0};
48239 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, 0};
48240 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, 0};
48241 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, 0};
48242 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, 0};
48243 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, 0};
48244 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, 0};
48245 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, 0};
48246 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, 0};
48247 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, 0};
48248 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, 0};
48249 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, 0};
48250 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, 0};
48251 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, 0};
48252 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, 0};
48253 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, 0};
48254 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, 0};
48255 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, 0};
48256 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, 0};
48257 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, 0};
48258 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, 0};
48259 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, 0};
48260 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, 0};
48261 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, 0};
48262 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, 0};
48263 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, 0};
48264 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, 0};
48265 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, 0};
48266 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, 0};
48267 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, 0};
48268 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, 0};
48269 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, 0};
48270 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, 0};
48271 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, 0};
48272 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, 0};
48273 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, 0};
48274 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, 0};
48275 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, 0};
48276 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, 0};
48277 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, 0};
48278 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, 0};
48279 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, 0};
48280 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, 0};
48281 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, 0};
48282 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, 0};
48283 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, 0};
48284 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, 0};
48285 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, 0};
48286 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, 0};
48287 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, 0};
48288 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, 0};
48289 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, 0};
48290 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, 0};
48291 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, 0};
48292 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, 0};
48293 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, 0};
48294 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, 0};
48295 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, 0};
48296 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, 0};
48297 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, 0};
48298 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, 0};
48299 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, 0};
48300 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, 0};
48301 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, 0};
48302 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, 0};
48303 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, 0};
48304 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, 0};
48305 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, 0};
48306 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, 0};
48307 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, 0};
48308 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, 0};
48309 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, 0};
48310 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, 0};
48311 static swig_type_info _swigt__ptrdiff_t = {"_ptrdiff_t", "ptrdiff_t", 0, 0, 0};
48312 static swig_type_info _swigt__std__ptrdiff_t = {"_std__ptrdiff_t", "std::ptrdiff_t", 0, 0, 0};
48313 static swig_type_info _swigt__unsigned_int = {"_unsigned_int", "unsigned int|std::size_t", 0, 0, 0};
48314
48315 static swig_type_info *swig_type_initial[] = {
48316 &_swigt__p_buffer,
48317 &_swigt__p_char,
48318 &_swigt__p_form_ops_t,
48319 &_swigt__p_int,
48320 &_swigt__p_long,
48321 &_swigt__p_unsigned_char,
48322 &_swigt__p_unsigned_int,
48323 &_swigt__p_unsigned_long,
48324 &_swigt__p_wxANIHandler,
48325 &_swigt__p_wxAcceleratorEntry,
48326 &_swigt__p_wxAcceleratorTable,
48327 &_swigt__p_wxActivateEvent,
48328 &_swigt__p_wxAppTraits,
48329 &_swigt__p_wxArrayString,
48330 &_swigt__p_wxBMPHandler,
48331 &_swigt__p_wxBitmap,
48332 &_swigt__p_wxBoxSizer,
48333 &_swigt__p_wxButton,
48334 &_swigt__p_wxCURHandler,
48335 &_swigt__p_wxCaret,
48336 &_swigt__p_wxChildFocusEvent,
48337 &_swigt__p_wxCloseEvent,
48338 &_swigt__p_wxColour,
48339 &_swigt__p_wxCommandEvent,
48340 &_swigt__p_wxContextMenuEvent,
48341 &_swigt__p_wxControl,
48342 &_swigt__p_wxControlWithItems,
48343 &_swigt__p_wxCursor,
48344 &_swigt__p_wxDC,
48345 &_swigt__p_wxDateEvent,
48346 &_swigt__p_wxDateTime,
48347 &_swigt__p_wxDisplayChangedEvent,
48348 &_swigt__p_wxDropFilesEvent,
48349 &_swigt__p_wxDuplexMode,
48350 &_swigt__p_wxEraseEvent,
48351 &_swigt__p_wxEvent,
48352 &_swigt__p_wxEventLoop,
48353 &_swigt__p_wxEventLoopActivator,
48354 &_swigt__p_wxEvtHandler,
48355 &_swigt__p_wxFSFile,
48356 &_swigt__p_wxFileSystem,
48357 &_swigt__p_wxFileSystemHandler,
48358 &_swigt__p_wxFlexGridSizer,
48359 &_swigt__p_wxFocusEvent,
48360 &_swigt__p_wxFont,
48361 &_swigt__p_wxFrame,
48362 &_swigt__p_wxGBPosition,
48363 &_swigt__p_wxGBSizerItem,
48364 &_swigt__p_wxGBSpan,
48365 &_swigt__p_wxGIFHandler,
48366 &_swigt__p_wxGridBagSizer,
48367 &_swigt__p_wxGridSizer,
48368 &_swigt__p_wxICOHandler,
48369 &_swigt__p_wxIconizeEvent,
48370 &_swigt__p_wxIdleEvent,
48371 &_swigt__p_wxImage,
48372 &_swigt__p_wxImageHandler,
48373 &_swigt__p_wxImageHistogram,
48374 &_swigt__p_wxImage_HSVValue,
48375 &_swigt__p_wxImage_RGBValue,
48376 &_swigt__p_wxIndividualLayoutConstraint,
48377 &_swigt__p_wxInitDialogEvent,
48378 &_swigt__p_wxInputStream,
48379 &_swigt__p_wxInternetFSHandler,
48380 &_swigt__p_wxItemContainer,
48381 &_swigt__p_wxJPEGHandler,
48382 &_swigt__p_wxKeyEvent,
48383 &_swigt__p_wxLayoutConstraints,
48384 &_swigt__p_wxMaximizeEvent,
48385 &_swigt__p_wxMemoryFSHandler,
48386 &_swigt__p_wxMenu,
48387 &_swigt__p_wxMenuBar,
48388 &_swigt__p_wxMenuBarBase,
48389 &_swigt__p_wxMenuEvent,
48390 &_swigt__p_wxMenuItem,
48391 &_swigt__p_wxMouseCaptureChangedEvent,
48392 &_swigt__p_wxMouseEvent,
48393 &_swigt__p_wxMoveEvent,
48394 &_swigt__p_wxNavigationKeyEvent,
48395 &_swigt__p_wxNcPaintEvent,
48396 &_swigt__p_wxNotifyEvent,
48397 &_swigt__p_wxObject,
48398 &_swigt__p_wxOutputStream,
48399 &_swigt__p_wxPCXHandler,
48400 &_swigt__p_wxPNGHandler,
48401 &_swigt__p_wxPNMHandler,
48402 &_swigt__p_wxPaintEvent,
48403 &_swigt__p_wxPaletteChangedEvent,
48404 &_swigt__p_wxPaperSize,
48405 &_swigt__p_wxPoint,
48406 &_swigt__p_wxPoint2D,
48407 &_swigt__p_wxPropagateOnce,
48408 &_swigt__p_wxPropagationDisabler,
48409 &_swigt__p_wxPyApp,
48410 &_swigt__p_wxPyCommandEvent,
48411 &_swigt__p_wxPyDropTarget,
48412 &_swigt__p_wxPyEvent,
48413 &_swigt__p_wxPyFileSystemHandler,
48414 &_swigt__p_wxPyImageHandler,
48415 &_swigt__p_wxPyInputStream,
48416 &_swigt__p_wxPySizer,
48417 &_swigt__p_wxPyValidator,
48418 &_swigt__p_wxQuantize,
48419 &_swigt__p_wxQueryNewPaletteEvent,
48420 &_swigt__p_wxRealPoint,
48421 &_swigt__p_wxRect,
48422 &_swigt__p_wxRegion,
48423 &_swigt__p_wxScrollEvent,
48424 &_swigt__p_wxScrollWinEvent,
48425 &_swigt__p_wxSetCursorEvent,
48426 &_swigt__p_wxShowEvent,
48427 &_swigt__p_wxSize,
48428 &_swigt__p_wxSizeEvent,
48429 &_swigt__p_wxSizer,
48430 &_swigt__p_wxSizerItem,
48431 &_swigt__p_wxStaticBox,
48432 &_swigt__p_wxStaticBoxSizer,
48433 &_swigt__p_wxStdDialogButtonSizer,
48434 &_swigt__p_wxSysColourChangedEvent,
48435 &_swigt__p_wxTIFFHandler,
48436 &_swigt__p_wxToolTip,
48437 &_swigt__p_wxUpdateUIEvent,
48438 &_swigt__p_wxValidator,
48439 &_swigt__p_wxVisualAttributes,
48440 &_swigt__p_wxWindow,
48441 &_swigt__p_wxWindowCreateEvent,
48442 &_swigt__p_wxWindowDestroyEvent,
48443 &_swigt__p_wxXPMHandler,
48444 &_swigt__p_wxZipFSHandler,
48445 &_swigt__ptrdiff_t,
48446 &_swigt__std__ptrdiff_t,
48447 &_swigt__unsigned_int,
48448 };
48449
48450 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
48451 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
48452 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
48453 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
48454 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
48455 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
48456 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
48457 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
48458 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
48459 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
48460 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
48461 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
48462 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
48463 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
48464 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}};
48465 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
48466 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}};
48467 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
48468 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}};
48469 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
48470 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
48471 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
48472 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
48473 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}};
48474 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
48475 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}};
48476 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
48477 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
48478 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
48479 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
48480 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
48481 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48482 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
48483 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
48484 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
48485 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}};
48486 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
48487 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
48488 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}};
48489 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
48490 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
48491 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}};
48492 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}};
48493 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
48494 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
48495 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
48496 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
48497 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
48498 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
48499 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
48500 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
48501 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}};
48502 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}};
48503 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48504 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
48505 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
48506 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}};
48507 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
48508 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
48509 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
48510 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
48511 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
48512 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
48513 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48514 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}};
48515 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
48516 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
48517 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
48518 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48519 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48520 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
48521 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
48522 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
48523 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
48524 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
48525 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48526 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
48527 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
48528 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
48529 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
48530 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
48531 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}};
48532 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
48533 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
48534 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
48535 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
48536 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
48537 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48538 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
48539 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
48540 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
48541 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
48542 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
48543 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
48544 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
48545 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
48546 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
48547 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
48548 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
48549 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
48550 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
48551 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
48552 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
48553 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
48554 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
48555 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
48556 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
48557 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
48558 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
48559 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
48560 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
48561 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
48562 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
48563 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}};
48564 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}};
48565 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
48566 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
48567 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
48568 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
48569 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
48570 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
48571 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
48572 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}};
48573 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
48574 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}};
48575 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
48576 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
48577 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
48578 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
48579 static swig_cast_info _swigc__ptrdiff_t[] = { {&_swigt__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
48580 static swig_cast_info _swigc__std__ptrdiff_t[] = { {&_swigt__std__ptrdiff_t, 0, 0, 0},{0, 0, 0, 0}};
48581 static swig_cast_info _swigc__unsigned_int[] = { {&_swigt__unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
48582
48583 static swig_cast_info *swig_cast_initial[] = {
48584 _swigc__p_buffer,
48585 _swigc__p_char,
48586 _swigc__p_form_ops_t,
48587 _swigc__p_int,
48588 _swigc__p_long,
48589 _swigc__p_unsigned_char,
48590 _swigc__p_unsigned_int,
48591 _swigc__p_unsigned_long,
48592 _swigc__p_wxANIHandler,
48593 _swigc__p_wxAcceleratorEntry,
48594 _swigc__p_wxAcceleratorTable,
48595 _swigc__p_wxActivateEvent,
48596 _swigc__p_wxAppTraits,
48597 _swigc__p_wxArrayString,
48598 _swigc__p_wxBMPHandler,
48599 _swigc__p_wxBitmap,
48600 _swigc__p_wxBoxSizer,
48601 _swigc__p_wxButton,
48602 _swigc__p_wxCURHandler,
48603 _swigc__p_wxCaret,
48604 _swigc__p_wxChildFocusEvent,
48605 _swigc__p_wxCloseEvent,
48606 _swigc__p_wxColour,
48607 _swigc__p_wxCommandEvent,
48608 _swigc__p_wxContextMenuEvent,
48609 _swigc__p_wxControl,
48610 _swigc__p_wxControlWithItems,
48611 _swigc__p_wxCursor,
48612 _swigc__p_wxDC,
48613 _swigc__p_wxDateEvent,
48614 _swigc__p_wxDateTime,
48615 _swigc__p_wxDisplayChangedEvent,
48616 _swigc__p_wxDropFilesEvent,
48617 _swigc__p_wxDuplexMode,
48618 _swigc__p_wxEraseEvent,
48619 _swigc__p_wxEvent,
48620 _swigc__p_wxEventLoop,
48621 _swigc__p_wxEventLoopActivator,
48622 _swigc__p_wxEvtHandler,
48623 _swigc__p_wxFSFile,
48624 _swigc__p_wxFileSystem,
48625 _swigc__p_wxFileSystemHandler,
48626 _swigc__p_wxFlexGridSizer,
48627 _swigc__p_wxFocusEvent,
48628 _swigc__p_wxFont,
48629 _swigc__p_wxFrame,
48630 _swigc__p_wxGBPosition,
48631 _swigc__p_wxGBSizerItem,
48632 _swigc__p_wxGBSpan,
48633 _swigc__p_wxGIFHandler,
48634 _swigc__p_wxGridBagSizer,
48635 _swigc__p_wxGridSizer,
48636 _swigc__p_wxICOHandler,
48637 _swigc__p_wxIconizeEvent,
48638 _swigc__p_wxIdleEvent,
48639 _swigc__p_wxImage,
48640 _swigc__p_wxImageHandler,
48641 _swigc__p_wxImageHistogram,
48642 _swigc__p_wxImage_HSVValue,
48643 _swigc__p_wxImage_RGBValue,
48644 _swigc__p_wxIndividualLayoutConstraint,
48645 _swigc__p_wxInitDialogEvent,
48646 _swigc__p_wxInputStream,
48647 _swigc__p_wxInternetFSHandler,
48648 _swigc__p_wxItemContainer,
48649 _swigc__p_wxJPEGHandler,
48650 _swigc__p_wxKeyEvent,
48651 _swigc__p_wxLayoutConstraints,
48652 _swigc__p_wxMaximizeEvent,
48653 _swigc__p_wxMemoryFSHandler,
48654 _swigc__p_wxMenu,
48655 _swigc__p_wxMenuBar,
48656 _swigc__p_wxMenuBarBase,
48657 _swigc__p_wxMenuEvent,
48658 _swigc__p_wxMenuItem,
48659 _swigc__p_wxMouseCaptureChangedEvent,
48660 _swigc__p_wxMouseEvent,
48661 _swigc__p_wxMoveEvent,
48662 _swigc__p_wxNavigationKeyEvent,
48663 _swigc__p_wxNcPaintEvent,
48664 _swigc__p_wxNotifyEvent,
48665 _swigc__p_wxObject,
48666 _swigc__p_wxOutputStream,
48667 _swigc__p_wxPCXHandler,
48668 _swigc__p_wxPNGHandler,
48669 _swigc__p_wxPNMHandler,
48670 _swigc__p_wxPaintEvent,
48671 _swigc__p_wxPaletteChangedEvent,
48672 _swigc__p_wxPaperSize,
48673 _swigc__p_wxPoint,
48674 _swigc__p_wxPoint2D,
48675 _swigc__p_wxPropagateOnce,
48676 _swigc__p_wxPropagationDisabler,
48677 _swigc__p_wxPyApp,
48678 _swigc__p_wxPyCommandEvent,
48679 _swigc__p_wxPyDropTarget,
48680 _swigc__p_wxPyEvent,
48681 _swigc__p_wxPyFileSystemHandler,
48682 _swigc__p_wxPyImageHandler,
48683 _swigc__p_wxPyInputStream,
48684 _swigc__p_wxPySizer,
48685 _swigc__p_wxPyValidator,
48686 _swigc__p_wxQuantize,
48687 _swigc__p_wxQueryNewPaletteEvent,
48688 _swigc__p_wxRealPoint,
48689 _swigc__p_wxRect,
48690 _swigc__p_wxRegion,
48691 _swigc__p_wxScrollEvent,
48692 _swigc__p_wxScrollWinEvent,
48693 _swigc__p_wxSetCursorEvent,
48694 _swigc__p_wxShowEvent,
48695 _swigc__p_wxSize,
48696 _swigc__p_wxSizeEvent,
48697 _swigc__p_wxSizer,
48698 _swigc__p_wxSizerItem,
48699 _swigc__p_wxStaticBox,
48700 _swigc__p_wxStaticBoxSizer,
48701 _swigc__p_wxStdDialogButtonSizer,
48702 _swigc__p_wxSysColourChangedEvent,
48703 _swigc__p_wxTIFFHandler,
48704 _swigc__p_wxToolTip,
48705 _swigc__p_wxUpdateUIEvent,
48706 _swigc__p_wxValidator,
48707 _swigc__p_wxVisualAttributes,
48708 _swigc__p_wxWindow,
48709 _swigc__p_wxWindowCreateEvent,
48710 _swigc__p_wxWindowDestroyEvent,
48711 _swigc__p_wxXPMHandler,
48712 _swigc__p_wxZipFSHandler,
48713 _swigc__ptrdiff_t,
48714 _swigc__std__ptrdiff_t,
48715 _swigc__unsigned_int,
48716 };
48717
48718
48719 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
48720
48721 static swig_const_info swig_const_table[] = {
48722 {0, 0, 0, 0.0, 0, 0}};
48723
48724 #ifdef __cplusplus
48725 }
48726 #endif
48727 /*************************************************************************
48728 * Type initialization:
48729 * This problem is tough by the requirement that no dynamic
48730 * memory is used. Also, since swig_type_info structures store pointers to
48731 * swig_cast_info structures and swig_cast_info structures store pointers back
48732 * to swig_type_info structures, we need some lookup code at initialization.
48733 * The idea is that swig generates all the structures that are needed.
48734 * The runtime then collects these partially filled structures.
48735 * The SWIG_InitializeModule function takes these initial arrays out of
48736 * swig_module, and does all the lookup, filling in the swig_module.types
48737 * array with the correct data and linking the correct swig_cast_info
48738 * structures together.
48739
48740 * The generated swig_type_info structures are assigned staticly to an initial
48741 * array. We just loop though that array, and handle each type individually.
48742 * First we lookup if this type has been already loaded, and if so, use the
48743 * loaded structure instead of the generated one. Then we have to fill in the
48744 * cast linked list. The cast data is initially stored in something like a
48745 * two-dimensional array. Each row corresponds to a type (there are the same
48746 * number of rows as there are in the swig_type_initial array). Each entry in
48747 * a column is one of the swig_cast_info structures for that type.
48748 * The cast_initial array is actually an array of arrays, because each row has
48749 * a variable number of columns. So to actually build the cast linked list,
48750 * we find the array of casts associated with the type, and loop through it
48751 * adding the casts to the list. The one last trick we need to do is making
48752 * sure the type pointer in the swig_cast_info struct is correct.
48753
48754 * First off, we lookup the cast->type name to see if it is already loaded.
48755 * There are three cases to handle:
48756 * 1) If the cast->type has already been loaded AND the type we are adding
48757 * casting info to has not been loaded (it is in this module), THEN we
48758 * replace the cast->type pointer with the type pointer that has already
48759 * been loaded.
48760 * 2) If BOTH types (the one we are adding casting info to, and the
48761 * cast->type) are loaded, THEN the cast info has already been loaded by
48762 * the previous module so we just ignore it.
48763 * 3) Finally, if cast->type has not already been loaded, then we add that
48764 * swig_cast_info to the linked list (because the cast->type) pointer will
48765 * be correct.
48766 **/
48767
48768 #ifdef __cplusplus
48769 extern "C" {
48770 #if 0
48771 } /* c-mode */
48772 #endif
48773 #endif
48774
48775 #if 0
48776 #define SWIGRUNTIME_DEBUG
48777 #endif
48778
48779 SWIGRUNTIME void
48780 SWIG_InitializeModule(void *clientdata) {
48781 size_t i;
48782 swig_module_info *module_head;
48783 static int init_run = 0;
48784
48785 clientdata = clientdata;
48786
48787 if (init_run) return;
48788 init_run = 1;
48789
48790 /* Initialize the swig_module */
48791 swig_module.type_initial = swig_type_initial;
48792 swig_module.cast_initial = swig_cast_initial;
48793
48794 /* Try and load any already created modules */
48795 module_head = SWIG_GetModule(clientdata);
48796 if (module_head) {
48797 swig_module.next = module_head->next;
48798 module_head->next = &swig_module;
48799 } else {
48800 /* This is the first module loaded */
48801 swig_module.next = &swig_module;
48802 SWIG_SetModule(clientdata, &swig_module);
48803 }
48804
48805 /* Now work on filling in swig_module.types */
48806 #ifdef SWIGRUNTIME_DEBUG
48807 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
48808 #endif
48809 for (i = 0; i < swig_module.size; ++i) {
48810 swig_type_info *type = 0;
48811 swig_type_info *ret;
48812 swig_cast_info *cast;
48813
48814 #ifdef SWIGRUNTIME_DEBUG
48815 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
48816 #endif
48817
48818 /* if there is another module already loaded */
48819 if (swig_module.next != &swig_module) {
48820 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
48821 }
48822 if (type) {
48823 /* Overwrite clientdata field */
48824 #ifdef SWIGRUNTIME_DEBUG
48825 printf("SWIG_InitializeModule: found type %s\n", type->name);
48826 #endif
48827 if (swig_module.type_initial[i]->clientdata) {
48828 type->clientdata = swig_module.type_initial[i]->clientdata;
48829 #ifdef SWIGRUNTIME_DEBUG
48830 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
48831 #endif
48832 }
48833 } else {
48834 type = swig_module.type_initial[i];
48835 }
48836
48837 /* Insert casting types */
48838 cast = swig_module.cast_initial[i];
48839 while (cast->type) {
48840 /* Don't need to add information already in the list */
48841 ret = 0;
48842 #ifdef SWIGRUNTIME_DEBUG
48843 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
48844 #endif
48845 if (swig_module.next != &swig_module) {
48846 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
48847 #ifdef SWIGRUNTIME_DEBUG
48848 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
48849 #endif
48850 }
48851 if (ret) {
48852 if (type == swig_module.type_initial[i]) {
48853 #ifdef SWIGRUNTIME_DEBUG
48854 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
48855 #endif
48856 cast->type = ret;
48857 ret = 0;
48858 } else {
48859 /* Check for casting already in the list */
48860 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
48861 #ifdef SWIGRUNTIME_DEBUG
48862 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
48863 #endif
48864 if (!ocast) ret = 0;
48865 }
48866 }
48867
48868 if (!ret) {
48869 #ifdef SWIGRUNTIME_DEBUG
48870 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
48871 #endif
48872 if (type->cast) {
48873 type->cast->prev = cast;
48874 cast->next = type->cast;
48875 }
48876 type->cast = cast;
48877 }
48878 cast++;
48879 }
48880 /* Set entry in modules->types array equal to the type */
48881 swig_module.types[i] = type;
48882 }
48883 swig_module.types[i] = 0;
48884
48885 #ifdef SWIGRUNTIME_DEBUG
48886 printf("**** SWIG_InitializeModule: Cast List ******\n");
48887 for (i = 0; i < swig_module.size; ++i) {
48888 int j = 0;
48889 swig_cast_info *cast = swig_module.cast_initial[i];
48890 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
48891 while (cast->type) {
48892 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
48893 cast++;
48894 ++j;
48895 }
48896 printf("---- Total casts: %d\n",j);
48897 }
48898 printf("**** SWIG_InitializeModule: Cast List ******\n");
48899 #endif
48900 }
48901
48902 /* This function will propagate the clientdata field of type to
48903 * any new swig_type_info structures that have been added into the list
48904 * of equivalent types. It is like calling
48905 * SWIG_TypeClientData(type, clientdata) a second time.
48906 */
48907 SWIGRUNTIME void
48908 SWIG_PropagateClientData(void) {
48909 size_t i;
48910 swig_cast_info *equiv;
48911 static int init_run = 0;
48912
48913 if (init_run) return;
48914 init_run = 1;
48915
48916 for (i = 0; i < swig_module.size; i++) {
48917 if (swig_module.types[i]->clientdata) {
48918 equiv = swig_module.types[i]->cast;
48919 while (equiv) {
48920 if (!equiv->converter) {
48921 if (equiv->type && !equiv->type->clientdata)
48922 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
48923 }
48924 equiv = equiv->next;
48925 }
48926 }
48927 }
48928 }
48929
48930 #ifdef __cplusplus
48931 #if 0
48932 {
48933 /* c-mode */
48934 #endif
48935 }
48936 #endif
48937
48938
48939
48940 #ifdef __cplusplus
48941 extern "C" {
48942 #endif
48943
48944 /* Python-specific SWIG API */
48945 #define SWIG_newvarlink() SWIG_Python_newvarlink()
48946 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
48947 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
48948
48949 /* -----------------------------------------------------------------------------
48950 * global variable support code.
48951 * ----------------------------------------------------------------------------- */
48952
48953 typedef struct swig_globalvar {
48954 char *name; /* Name of global variable */
48955 PyObject *(*get_attr)(void); /* Return the current value */
48956 int (*set_attr)(PyObject *); /* Set the value */
48957 struct swig_globalvar *next;
48958 } swig_globalvar;
48959
48960 typedef struct swig_varlinkobject {
48961 PyObject_HEAD
48962 swig_globalvar *vars;
48963 } swig_varlinkobject;
48964
48965 SWIGINTERN PyObject *
48966 swig_varlink_repr(swig_varlinkobject *v) {
48967 v = v;
48968 return PyString_FromString("<Swig global variables>");
48969 }
48970
48971 SWIGINTERN int
48972 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
48973 swig_globalvar *var;
48974 flags = flags;
48975 fprintf(fp,"Swig global variables { ");
48976 for (var = v->vars; var; var=var->next) {
48977 fprintf(fp,"%s", var->name);
48978 if (var->next) fprintf(fp,", ");
48979 }
48980 fprintf(fp," }\n");
48981 return 0;
48982 }
48983
48984 SWIGINTERN PyObject *
48985 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
48986 swig_globalvar *var = v->vars;
48987 while (var) {
48988 if (strcmp(var->name,n) == 0) {
48989 return (*var->get_attr)();
48990 }
48991 var = var->next;
48992 }
48993 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48994 return NULL;
48995 }
48996
48997 SWIGINTERN int
48998 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
48999 swig_globalvar *var = v->vars;
49000 while (var) {
49001 if (strcmp(var->name,n) == 0) {
49002 return (*var->set_attr)(p);
49003 }
49004 var = var->next;
49005 }
49006 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
49007 return 1;
49008 }
49009
49010 SWIGINTERN PyTypeObject*
49011 swig_varlink_type(void) {
49012 static char varlink__doc__[] = "Swig var link object";
49013 static PyTypeObject varlink_type
49014 #if !defined(__cplusplus)
49015 ;
49016 static int type_init = 0;
49017 if (!type_init) {
49018 PyTypeObject tmp
49019 #endif
49020 = {
49021 PyObject_HEAD_INIT(&PyType_Type)
49022 0, /* Number of items in variable part (ob_size) */
49023 (char *)"swigvarlink", /* Type name (tp_name) */
49024 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
49025 0, /* Itemsize (tp_itemsize) */
49026 0, /* Deallocator (tp_dealloc) */
49027 (printfunc) swig_varlink_print, /* Print (tp_print) */
49028 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
49029 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
49030 0, /* tp_compare */
49031 (reprfunc) swig_varlink_repr, /* tp_repr */
49032 0, /* tp_as_number */
49033 0, /* tp_as_sequence */
49034 0, /* tp_as_mapping */
49035 0, /* tp_hash */
49036 0, /* tp_call */
49037 0, /* tp_str */
49038 0, /* tp_getattro */
49039 0, /* tp_setattro */
49040 0, /* tp_as_buffer */
49041 0, /* tp_flags */
49042 varlink__doc__, /* tp_doc */
49043 #if PY_VERSION_HEX >= 0x02000000
49044 0, /* tp_traverse */
49045 0, /* tp_clear */
49046 #endif
49047 #if PY_VERSION_HEX >= 0x02010000
49048 0, /* tp_richcompare */
49049 0, /* tp_weaklistoffset */
49050 #endif
49051 #if PY_VERSION_HEX >= 0x02020000
49052 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
49053 #endif
49054 #if PY_VERSION_HEX >= 0x02030000
49055 0, /* tp_del */
49056 #endif
49057 #ifdef COUNT_ALLOCS
49058 0,0,0,0 /* tp_alloc -> tp_next */
49059 #endif
49060 };
49061 #if !defined(__cplusplus)
49062 varlink_type = tmp;
49063 type_init = 1;
49064 }
49065 #endif
49066 return &varlink_type;
49067 }
49068
49069 /* Create a variable linking object for use later */
49070 SWIGINTERN PyObject *
49071 SWIG_Python_newvarlink(void) {
49072 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
49073 if (result) {
49074 result->vars = 0;
49075 }
49076 return ((PyObject*) result);
49077 }
49078
49079 SWIGINTERN void
49080 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
49081 swig_varlinkobject *v = (swig_varlinkobject *) p;
49082 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
49083 if (gv) {
49084 size_t size = strlen(name)+1;
49085 gv->name = (char *)malloc(size);
49086 if (gv->name) {
49087 strncpy(gv->name,name,size);
49088 gv->get_attr = get_attr;
49089 gv->set_attr = set_attr;
49090 gv->next = v->vars;
49091 }
49092 }
49093 v->vars = gv;
49094 }
49095
49096 /* -----------------------------------------------------------------------------
49097 * constants/methods manipulation
49098 * ----------------------------------------------------------------------------- */
49099
49100 /* Install Constants */
49101 SWIGINTERN void
49102 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
49103 PyObject *obj = 0;
49104 size_t i;
49105 for (i = 0; constants[i].type; ++i) {
49106 switch(constants[i].type) {
49107 case SWIG_PY_INT:
49108 obj = PyInt_FromLong(constants[i].lvalue);
49109 break;
49110 case SWIG_PY_FLOAT:
49111 obj = PyFloat_FromDouble(constants[i].dvalue);
49112 break;
49113 case SWIG_PY_STRING:
49114 if (constants[i].pvalue) {
49115 obj = PyString_FromString((char *) constants[i].pvalue);
49116 } else {
49117 Py_INCREF(Py_None);
49118 obj = Py_None;
49119 }
49120 break;
49121 case SWIG_PY_POINTER:
49122 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
49123 break;
49124 case SWIG_PY_BINARY:
49125 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
49126 break;
49127 default:
49128 obj = 0;
49129 break;
49130 }
49131 if (obj) {
49132 PyDict_SetItemString(d,constants[i].name,obj);
49133 Py_DECREF(obj);
49134 }
49135 }
49136 }
49137
49138 /* -----------------------------------------------------------------------------*/
49139 /* Fix SwigMethods to carry the callback ptrs when needed */
49140 /* -----------------------------------------------------------------------------*/
49141
49142 SWIGINTERN void
49143 SWIG_Python_FixMethods(PyMethodDef *methods,
49144 swig_const_info *const_table,
49145 swig_type_info **types,
49146 swig_type_info **types_initial) {
49147 size_t i;
49148 for (i = 0; methods[i].ml_name; ++i) {
49149 char *c = methods[i].ml_doc;
49150 if (c && (c = strstr(c, "swig_ptr: "))) {
49151 int j;
49152 swig_const_info *ci = 0;
49153 char *name = c + 10;
49154 for (j = 0; const_table[j].type; ++j) {
49155 if (strncmp(const_table[j].name, name,
49156 strlen(const_table[j].name)) == 0) {
49157 ci = &(const_table[j]);
49158 break;
49159 }
49160 }
49161 if (ci) {
49162 size_t shift = (ci->ptype) - types;
49163 swig_type_info *ty = types_initial[shift];
49164 size_t ldoc = (c - methods[i].ml_doc);
49165 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
49166 char *ndoc = (char*)malloc(ldoc + lptr + 10);
49167 if (ndoc) {
49168 char *buff = ndoc;
49169 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
49170 if (ptr) {
49171 strncpy(buff, methods[i].ml_doc, ldoc);
49172 buff += ldoc;
49173 strncpy(buff, "swig_ptr: ", 10);
49174 buff += 10;
49175 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
49176 methods[i].ml_doc = ndoc;
49177 }
49178 }
49179 }
49180 }
49181 }
49182 }
49183
49184 /* -----------------------------------------------------------------------------*
49185 * Initialize type list
49186 * -----------------------------------------------------------------------------*/
49187
49188 #ifdef __cplusplus
49189 }
49190 #endif
49191
49192 /* -----------------------------------------------------------------------------*
49193 * Partial Init method
49194 * -----------------------------------------------------------------------------*/
49195
49196 #ifdef __cplusplus
49197 extern "C"
49198 #endif
49199 SWIGEXPORT void SWIG_init(void) {
49200 static PyObject *SWIG_globals = 0;
49201 PyObject *m, *d;
49202 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
49203
49204 /* Fix SwigMethods to carry the callback ptrs when needed */
49205 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
49206
49207 m = Py_InitModule((char *) SWIG_name, SwigMethods);
49208 d = PyModule_GetDict(m);
49209
49210 SWIG_InitializeModule(0);
49211 SWIG_InstallConstants(d,swig_const_table);
49212
49213
49214 #ifndef wxPyUSE_EXPORT
49215 // Make our API structure a CObject so other modules can import it
49216 // from this module.
49217 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
49218 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
49219 Py_XDECREF(cobj);
49220 #endif
49221
49222 {
49223 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int(static_cast<int >(wxNOT_FOUND)));
49224 }
49225 {
49226 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int(static_cast<int >(wxVSCROLL)));
49227 }
49228 {
49229 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int(static_cast<int >(wxHSCROLL)));
49230 }
49231 {
49232 PyDict_SetItemString(d,"CAPTION", SWIG_From_int(static_cast<int >(wxCAPTION)));
49233 }
49234 {
49235 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int(static_cast<int >(wxDOUBLE_BORDER)));
49236 }
49237 {
49238 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int(static_cast<int >(wxSUNKEN_BORDER)));
49239 }
49240 {
49241 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int(static_cast<int >(wxRAISED_BORDER)));
49242 }
49243 {
49244 PyDict_SetItemString(d,"BORDER", SWIG_From_int(static_cast<int >(wxBORDER)));
49245 }
49246 {
49247 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int(static_cast<int >(wxSIMPLE_BORDER)));
49248 }
49249 {
49250 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int(static_cast<int >(wxSTATIC_BORDER)));
49251 }
49252 {
49253 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int(static_cast<int >(wxTRANSPARENT_WINDOW)));
49254 }
49255 {
49256 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int(static_cast<int >(wxNO_BORDER)));
49257 }
49258 {
49259 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int(static_cast<int >(wxDEFAULT_CONTROL_BORDER)));
49260 }
49261 {
49262 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int(static_cast<int >(wxDEFAULT_STATUSBAR_STYLE)));
49263 }
49264 {
49265 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int(static_cast<int >(wxTAB_TRAVERSAL)));
49266 }
49267 {
49268 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int(static_cast<int >(wxWANTS_CHARS)));
49269 }
49270 {
49271 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int(static_cast<int >(wxPOPUP_WINDOW)));
49272 }
49273 {
49274 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int(static_cast<int >(wxCENTER_FRAME)));
49275 }
49276 {
49277 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int(static_cast<int >(wxCENTRE_ON_SCREEN)));
49278 }
49279 {
49280 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int(static_cast<int >(wxCENTER_ON_SCREEN)));
49281 }
49282 {
49283 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int(static_cast<int >(wxCLIP_CHILDREN)));
49284 }
49285 {
49286 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int(static_cast<int >(wxCLIP_SIBLINGS)));
49287 }
49288 {
49289 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int(static_cast<int >(wxALWAYS_SHOW_SB)));
49290 }
49291 {
49292 PyDict_SetItemString(d,"RETAINED", SWIG_From_int(static_cast<int >(wxRETAINED)));
49293 }
49294 {
49295 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int(static_cast<int >(wxBACKINGSTORE)));
49296 }
49297 {
49298 PyDict_SetItemString(d,"COLOURED", SWIG_From_int(static_cast<int >(wxCOLOURED)));
49299 }
49300 {
49301 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int(static_cast<int >(wxFIXED_LENGTH)));
49302 }
49303 {
49304 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int(static_cast<int >(wxLB_NEEDED_SB)));
49305 }
49306 {
49307 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int(static_cast<int >(wxLB_ALWAYS_SB)));
49308 }
49309 {
49310 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int(static_cast<int >(wxLB_SORT)));
49311 }
49312 {
49313 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int(static_cast<int >(wxLB_SINGLE)));
49314 }
49315 {
49316 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int(static_cast<int >(wxLB_MULTIPLE)));
49317 }
49318 {
49319 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int(static_cast<int >(wxLB_EXTENDED)));
49320 }
49321 {
49322 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int(static_cast<int >(wxLB_OWNERDRAW)));
49323 }
49324 {
49325 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int(static_cast<int >(wxLB_HSCROLL)));
49326 }
49327 {
49328 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int(static_cast<int >(wxPROCESS_ENTER)));
49329 }
49330 {
49331 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int(static_cast<int >(wxPASSWORD)));
49332 }
49333 {
49334 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int(static_cast<int >(wxCB_SIMPLE)));
49335 }
49336 {
49337 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int(static_cast<int >(wxCB_DROPDOWN)));
49338 }
49339 {
49340 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int(static_cast<int >(wxCB_SORT)));
49341 }
49342 {
49343 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int(static_cast<int >(wxCB_READONLY)));
49344 }
49345 {
49346 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int(static_cast<int >(wxRA_HORIZONTAL)));
49347 }
49348 {
49349 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int(static_cast<int >(wxRA_VERTICAL)));
49350 }
49351 {
49352 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int(static_cast<int >(wxRA_SPECIFY_ROWS)));
49353 }
49354 {
49355 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int(static_cast<int >(wxRA_SPECIFY_COLS)));
49356 }
49357 {
49358 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int(static_cast<int >(wxRA_USE_CHECKBOX)));
49359 }
49360 {
49361 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int(static_cast<int >(wxRB_GROUP)));
49362 }
49363 {
49364 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int(static_cast<int >(wxRB_SINGLE)));
49365 }
49366 {
49367 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int(static_cast<int >(wxSB_HORIZONTAL)));
49368 }
49369 {
49370 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int(static_cast<int >(wxSB_VERTICAL)));
49371 }
49372 {
49373 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int(static_cast<int >(wxRB_USE_CHECKBOX)));
49374 }
49375 {
49376 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int(static_cast<int >(wxST_SIZEGRIP)));
49377 }
49378 {
49379 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int(static_cast<int >(wxST_NO_AUTORESIZE)));
49380 }
49381 {
49382 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int(static_cast<int >(wxFLOOD_SURFACE)));
49383 }
49384 {
49385 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int(static_cast<int >(wxFLOOD_BORDER)));
49386 }
49387 {
49388 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int(static_cast<int >(wxODDEVEN_RULE)));
49389 }
49390 {
49391 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int(static_cast<int >(wxWINDING_RULE)));
49392 }
49393 {
49394 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int(static_cast<int >(wxTOOL_TOP)));
49395 }
49396 {
49397 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int(static_cast<int >(wxTOOL_BOTTOM)));
49398 }
49399 {
49400 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int(static_cast<int >(wxTOOL_LEFT)));
49401 }
49402 {
49403 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int(static_cast<int >(wxTOOL_RIGHT)));
49404 }
49405 {
49406 PyDict_SetItemString(d,"OK", SWIG_From_int(static_cast<int >(wxOK)));
49407 }
49408 {
49409 PyDict_SetItemString(d,"YES_NO", SWIG_From_int(static_cast<int >(wxYES_NO)));
49410 }
49411 {
49412 PyDict_SetItemString(d,"CANCEL", SWIG_From_int(static_cast<int >(wxCANCEL)));
49413 }
49414 {
49415 PyDict_SetItemString(d,"YES", SWIG_From_int(static_cast<int >(wxYES)));
49416 }
49417 {
49418 PyDict_SetItemString(d,"NO", SWIG_From_int(static_cast<int >(wxNO)));
49419 }
49420 {
49421 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int(static_cast<int >(wxNO_DEFAULT)));
49422 }
49423 {
49424 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int(static_cast<int >(wxYES_DEFAULT)));
49425 }
49426 {
49427 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int(static_cast<int >(wxICON_EXCLAMATION)));
49428 }
49429 {
49430 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int(static_cast<int >(wxICON_HAND)));
49431 }
49432 {
49433 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int(static_cast<int >(wxICON_QUESTION)));
49434 }
49435 {
49436 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int(static_cast<int >(wxICON_INFORMATION)));
49437 }
49438 {
49439 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int(static_cast<int >(wxICON_STOP)));
49440 }
49441 {
49442 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int(static_cast<int >(wxICON_ASTERISK)));
49443 }
49444 {
49445 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int(static_cast<int >(wxICON_MASK)));
49446 }
49447 {
49448 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int(static_cast<int >(wxICON_WARNING)));
49449 }
49450 {
49451 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int(static_cast<int >(wxICON_ERROR)));
49452 }
49453 {
49454 PyDict_SetItemString(d,"FORWARD", SWIG_From_int(static_cast<int >(wxFORWARD)));
49455 }
49456 {
49457 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int(static_cast<int >(wxBACKWARD)));
49458 }
49459 {
49460 PyDict_SetItemString(d,"RESET", SWIG_From_int(static_cast<int >(wxRESET)));
49461 }
49462 {
49463 PyDict_SetItemString(d,"HELP", SWIG_From_int(static_cast<int >(wxHELP)));
49464 }
49465 {
49466 PyDict_SetItemString(d,"MORE", SWIG_From_int(static_cast<int >(wxMORE)));
49467 }
49468 {
49469 PyDict_SetItemString(d,"SETUP", SWIG_From_int(static_cast<int >(wxSETUP)));
49470 }
49471 {
49472 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int(static_cast<int >(wxSIZE_AUTO_WIDTH)));
49473 }
49474 {
49475 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int(static_cast<int >(wxSIZE_AUTO_HEIGHT)));
49476 }
49477 {
49478 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int(static_cast<int >(wxSIZE_AUTO)));
49479 }
49480 {
49481 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int(static_cast<int >(wxSIZE_USE_EXISTING)));
49482 }
49483 {
49484 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int(static_cast<int >(wxSIZE_ALLOW_MINUS_ONE)));
49485 }
49486 {
49487 PyDict_SetItemString(d,"SIZE_FORCE", SWIG_From_int(static_cast<int >(wxSIZE_FORCE)));
49488 }
49489 {
49490 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int(static_cast<int >(wxPORTRAIT)));
49491 }
49492 {
49493 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int(static_cast<int >(wxLANDSCAPE)));
49494 }
49495 {
49496 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_HIGH)));
49497 }
49498 {
49499 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_MEDIUM)));
49500 }
49501 {
49502 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_LOW)));
49503 }
49504 {
49505 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int(static_cast<int >(wxPRINT_QUALITY_DRAFT)));
49506 }
49507 {
49508 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int(static_cast<int >(wxID_ANY)));
49509 }
49510 {
49511 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int(static_cast<int >(wxID_SEPARATOR)));
49512 }
49513 {
49514 PyDict_SetItemString(d,"ID_NONE", SWIG_From_int(static_cast<int >(wxID_NONE)));
49515 }
49516 {
49517 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int(static_cast<int >(wxID_LOWEST)));
49518 }
49519 {
49520 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int(static_cast<int >(wxID_OPEN)));
49521 }
49522 {
49523 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int(static_cast<int >(wxID_CLOSE)));
49524 }
49525 {
49526 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int(static_cast<int >(wxID_NEW)));
49527 }
49528 {
49529 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int(static_cast<int >(wxID_SAVE)));
49530 }
49531 {
49532 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int(static_cast<int >(wxID_SAVEAS)));
49533 }
49534 {
49535 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int(static_cast<int >(wxID_REVERT)));
49536 }
49537 {
49538 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int(static_cast<int >(wxID_EXIT)));
49539 }
49540 {
49541 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int(static_cast<int >(wxID_UNDO)));
49542 }
49543 {
49544 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int(static_cast<int >(wxID_REDO)));
49545 }
49546 {
49547 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int(static_cast<int >(wxID_HELP)));
49548 }
49549 {
49550 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int(static_cast<int >(wxID_PRINT)));
49551 }
49552 {
49553 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int(static_cast<int >(wxID_PRINT_SETUP)));
49554 }
49555 {
49556 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int(static_cast<int >(wxID_PREVIEW)));
49557 }
49558 {
49559 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int(static_cast<int >(wxID_ABOUT)));
49560 }
49561 {
49562 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int(static_cast<int >(wxID_HELP_CONTENTS)));
49563 }
49564 {
49565 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int(static_cast<int >(wxID_HELP_COMMANDS)));
49566 }
49567 {
49568 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int(static_cast<int >(wxID_HELP_PROCEDURES)));
49569 }
49570 {
49571 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int(static_cast<int >(wxID_HELP_CONTEXT)));
49572 }
49573 {
49574 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int(static_cast<int >(wxID_CLOSE_ALL)));
49575 }
49576 {
49577 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int(static_cast<int >(wxID_PREFERENCES)));
49578 }
49579 {
49580 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int(static_cast<int >(wxID_CUT)));
49581 }
49582 {
49583 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int(static_cast<int >(wxID_COPY)));
49584 }
49585 {
49586 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int(static_cast<int >(wxID_PASTE)));
49587 }
49588 {
49589 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int(static_cast<int >(wxID_CLEAR)));
49590 }
49591 {
49592 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int(static_cast<int >(wxID_FIND)));
49593 }
49594 {
49595 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int(static_cast<int >(wxID_DUPLICATE)));
49596 }
49597 {
49598 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int(static_cast<int >(wxID_SELECTALL)));
49599 }
49600 {
49601 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int(static_cast<int >(wxID_DELETE)));
49602 }
49603 {
49604 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int(static_cast<int >(wxID_REPLACE)));
49605 }
49606 {
49607 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int(static_cast<int >(wxID_REPLACE_ALL)));
49608 }
49609 {
49610 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int(static_cast<int >(wxID_PROPERTIES)));
49611 }
49612 {
49613 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int(static_cast<int >(wxID_VIEW_DETAILS)));
49614 }
49615 {
49616 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int(static_cast<int >(wxID_VIEW_LARGEICONS)));
49617 }
49618 {
49619 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int(static_cast<int >(wxID_VIEW_SMALLICONS)));
49620 }
49621 {
49622 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int(static_cast<int >(wxID_VIEW_LIST)));
49623 }
49624 {
49625 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTDATE)));
49626 }
49627 {
49628 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTNAME)));
49629 }
49630 {
49631 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTSIZE)));
49632 }
49633 {
49634 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int(static_cast<int >(wxID_VIEW_SORTTYPE)));
49635 }
49636 {
49637 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int(static_cast<int >(wxID_FILE1)));
49638 }
49639 {
49640 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int(static_cast<int >(wxID_FILE2)));
49641 }
49642 {
49643 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int(static_cast<int >(wxID_FILE3)));
49644 }
49645 {
49646 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int(static_cast<int >(wxID_FILE4)));
49647 }
49648 {
49649 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int(static_cast<int >(wxID_FILE5)));
49650 }
49651 {
49652 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int(static_cast<int >(wxID_FILE6)));
49653 }
49654 {
49655 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int(static_cast<int >(wxID_FILE7)));
49656 }
49657 {
49658 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int(static_cast<int >(wxID_FILE8)));
49659 }
49660 {
49661 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int(static_cast<int >(wxID_FILE9)));
49662 }
49663 {
49664 PyDict_SetItemString(d,"ID_OK", SWIG_From_int(static_cast<int >(wxID_OK)));
49665 }
49666 {
49667 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int(static_cast<int >(wxID_CANCEL)));
49668 }
49669 {
49670 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int(static_cast<int >(wxID_APPLY)));
49671 }
49672 {
49673 PyDict_SetItemString(d,"ID_YES", SWIG_From_int(static_cast<int >(wxID_YES)));
49674 }
49675 {
49676 PyDict_SetItemString(d,"ID_NO", SWIG_From_int(static_cast<int >(wxID_NO)));
49677 }
49678 {
49679 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int(static_cast<int >(wxID_STATIC)));
49680 }
49681 {
49682 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int(static_cast<int >(wxID_FORWARD)));
49683 }
49684 {
49685 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int(static_cast<int >(wxID_BACKWARD)));
49686 }
49687 {
49688 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int(static_cast<int >(wxID_DEFAULT)));
49689 }
49690 {
49691 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int(static_cast<int >(wxID_MORE)));
49692 }
49693 {
49694 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int(static_cast<int >(wxID_SETUP)));
49695 }
49696 {
49697 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int(static_cast<int >(wxID_RESET)));
49698 }
49699 {
49700 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int(static_cast<int >(wxID_CONTEXT_HELP)));
49701 }
49702 {
49703 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int(static_cast<int >(wxID_YESTOALL)));
49704 }
49705 {
49706 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int(static_cast<int >(wxID_NOTOALL)));
49707 }
49708 {
49709 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int(static_cast<int >(wxID_ABORT)));
49710 }
49711 {
49712 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int(static_cast<int >(wxID_RETRY)));
49713 }
49714 {
49715 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int(static_cast<int >(wxID_IGNORE)));
49716 }
49717 {
49718 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int(static_cast<int >(wxID_ADD)));
49719 }
49720 {
49721 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int(static_cast<int >(wxID_REMOVE)));
49722 }
49723 {
49724 PyDict_SetItemString(d,"ID_UP", SWIG_From_int(static_cast<int >(wxID_UP)));
49725 }
49726 {
49727 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int(static_cast<int >(wxID_DOWN)));
49728 }
49729 {
49730 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int(static_cast<int >(wxID_HOME)));
49731 }
49732 {
49733 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int(static_cast<int >(wxID_REFRESH)));
49734 }
49735 {
49736 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int(static_cast<int >(wxID_STOP)));
49737 }
49738 {
49739 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int(static_cast<int >(wxID_INDEX)));
49740 }
49741 {
49742 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int(static_cast<int >(wxID_BOLD)));
49743 }
49744 {
49745 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int(static_cast<int >(wxID_ITALIC)));
49746 }
49747 {
49748 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_CENTER)));
49749 }
49750 {
49751 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_FILL)));
49752 }
49753 {
49754 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_RIGHT)));
49755 }
49756 {
49757 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int(static_cast<int >(wxID_JUSTIFY_LEFT)));
49758 }
49759 {
49760 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int(static_cast<int >(wxID_UNDERLINE)));
49761 }
49762 {
49763 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int(static_cast<int >(wxID_INDENT)));
49764 }
49765 {
49766 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int(static_cast<int >(wxID_UNINDENT)));
49767 }
49768 {
49769 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int(static_cast<int >(wxID_ZOOM_100)));
49770 }
49771 {
49772 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int(static_cast<int >(wxID_ZOOM_FIT)));
49773 }
49774 {
49775 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int(static_cast<int >(wxID_ZOOM_IN)));
49776 }
49777 {
49778 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int(static_cast<int >(wxID_ZOOM_OUT)));
49779 }
49780 {
49781 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int(static_cast<int >(wxID_UNDELETE)));
49782 }
49783 {
49784 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int(static_cast<int >(wxID_REVERT_TO_SAVED)));
49785 }
49786 {
49787 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int(static_cast<int >(wxID_HIGHEST)));
49788 }
49789 {
49790 PyDict_SetItemString(d,"OPEN", SWIG_From_int(static_cast<int >(wxOPEN)));
49791 }
49792 {
49793 PyDict_SetItemString(d,"SAVE", SWIG_From_int(static_cast<int >(wxSAVE)));
49794 }
49795 {
49796 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int(static_cast<int >(wxHIDE_READONLY)));
49797 }
49798 {
49799 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int(static_cast<int >(wxOVERWRITE_PROMPT)));
49800 }
49801 {
49802 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int(static_cast<int >(wxFILE_MUST_EXIST)));
49803 }
49804 {
49805 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int(static_cast<int >(wxMULTIPLE)));
49806 }
49807 {
49808 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int(static_cast<int >(wxCHANGE_DIR)));
49809 }
49810 {
49811 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int(static_cast<int >(wxACCEL_ALT)));
49812 }
49813 {
49814 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int(static_cast<int >(wxACCEL_CTRL)));
49815 }
49816 {
49817 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int(static_cast<int >(wxACCEL_SHIFT)));
49818 }
49819 {
49820 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int(static_cast<int >(wxACCEL_NORMAL)));
49821 }
49822 {
49823 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int(static_cast<int >(wxPD_AUTO_HIDE)));
49824 }
49825 {
49826 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int(static_cast<int >(wxPD_APP_MODAL)));
49827 }
49828 {
49829 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int(static_cast<int >(wxPD_CAN_ABORT)));
49830 }
49831 {
49832 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int(static_cast<int >(wxPD_ELAPSED_TIME)));
49833 }
49834 {
49835 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int(static_cast<int >(wxPD_ESTIMATED_TIME)));
49836 }
49837 {
49838 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int(static_cast<int >(wxPD_REMAINING_TIME)));
49839 }
49840 {
49841 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int(static_cast<int >(wxPD_SMOOTH)));
49842 }
49843 {
49844 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int(static_cast<int >(wxPD_CAN_SKIP)));
49845 }
49846 {
49847 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int(static_cast<int >(wxDD_NEW_DIR_BUTTON)));
49848 }
49849 {
49850 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int(static_cast<int >(wxDD_DEFAULT_STYLE)));
49851 }
49852 {
49853 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int(static_cast<int >(wxMENU_TEAROFF)));
49854 }
49855 {
49856 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int(static_cast<int >(wxMB_DOCKABLE)));
49857 }
49858 {
49859 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int(static_cast<int >(wxNO_FULL_REPAINT_ON_RESIZE)));
49860 }
49861 {
49862 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int(static_cast<int >(wxFULL_REPAINT_ON_RESIZE)));
49863 }
49864 {
49865 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int(static_cast<int >(wxLI_HORIZONTAL)));
49866 }
49867 {
49868 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int(static_cast<int >(wxLI_VERTICAL)));
49869 }
49870 {
49871 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int(static_cast<int >(wxWS_EX_VALIDATE_RECURSIVELY)));
49872 }
49873 {
49874 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int(static_cast<int >(wxWS_EX_BLOCK_EVENTS)));
49875 }
49876 {
49877 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int(static_cast<int >(wxWS_EX_TRANSIENT)));
49878 }
49879 {
49880 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int(static_cast<int >(wxWS_EX_THEMED_BACKGROUND)));
49881 }
49882 {
49883 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int(static_cast<int >(wxWS_EX_PROCESS_IDLE)));
49884 }
49885 {
49886 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int(static_cast<int >(wxWS_EX_PROCESS_UI_UPDATES)));
49887 }
49888 {
49889 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int(static_cast<int >(wxMM_TEXT)));
49890 }
49891 {
49892 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int(static_cast<int >(wxMM_LOMETRIC)));
49893 }
49894 {
49895 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int(static_cast<int >(wxMM_HIMETRIC)));
49896 }
49897 {
49898 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int(static_cast<int >(wxMM_LOENGLISH)));
49899 }
49900 {
49901 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int(static_cast<int >(wxMM_HIENGLISH)));
49902 }
49903 {
49904 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int(static_cast<int >(wxMM_TWIPS)));
49905 }
49906 {
49907 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int(static_cast<int >(wxMM_ISOTROPIC)));
49908 }
49909 {
49910 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int(static_cast<int >(wxMM_ANISOTROPIC)));
49911 }
49912 {
49913 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int(static_cast<int >(wxMM_POINTS)));
49914 }
49915 {
49916 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int(static_cast<int >(wxMM_METRIC)));
49917 }
49918 {
49919 PyDict_SetItemString(d,"CENTRE", SWIG_From_int(static_cast<int >(wxCENTRE)));
49920 }
49921 {
49922 PyDict_SetItemString(d,"CENTER", SWIG_From_int(static_cast<int >(wxCENTER)));
49923 }
49924 {
49925 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int(static_cast<int >(wxHORIZONTAL)));
49926 }
49927 {
49928 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int(static_cast<int >(wxVERTICAL)));
49929 }
49930 {
49931 PyDict_SetItemString(d,"BOTH", SWIG_From_int(static_cast<int >(wxBOTH)));
49932 }
49933 {
49934 PyDict_SetItemString(d,"LEFT", SWIG_From_int(static_cast<int >(wxLEFT)));
49935 }
49936 {
49937 PyDict_SetItemString(d,"RIGHT", SWIG_From_int(static_cast<int >(wxRIGHT)));
49938 }
49939 {
49940 PyDict_SetItemString(d,"UP", SWIG_From_int(static_cast<int >(wxUP)));
49941 }
49942 {
49943 PyDict_SetItemString(d,"DOWN", SWIG_From_int(static_cast<int >(wxDOWN)));
49944 }
49945 {
49946 PyDict_SetItemString(d,"TOP", SWIG_From_int(static_cast<int >(wxTOP)));
49947 }
49948 {
49949 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int(static_cast<int >(wxBOTTOM)));
49950 }
49951 {
49952 PyDict_SetItemString(d,"NORTH", SWIG_From_int(static_cast<int >(wxNORTH)));
49953 }
49954 {
49955 PyDict_SetItemString(d,"SOUTH", SWIG_From_int(static_cast<int >(wxSOUTH)));
49956 }
49957 {
49958 PyDict_SetItemString(d,"WEST", SWIG_From_int(static_cast<int >(wxWEST)));
49959 }
49960 {
49961 PyDict_SetItemString(d,"EAST", SWIG_From_int(static_cast<int >(wxEAST)));
49962 }
49963 {
49964 PyDict_SetItemString(d,"ALL", SWIG_From_int(static_cast<int >(wxALL)));
49965 }
49966 {
49967 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int(static_cast<int >(wxALIGN_NOT)));
49968 }
49969 {
49970 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTER_HORIZONTAL)));
49971 }
49972 {
49973 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE_HORIZONTAL)));
49974 }
49975 {
49976 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int(static_cast<int >(wxALIGN_LEFT)));
49977 }
49978 {
49979 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int(static_cast<int >(wxALIGN_TOP)));
49980 }
49981 {
49982 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int(static_cast<int >(wxALIGN_RIGHT)));
49983 }
49984 {
49985 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int(static_cast<int >(wxALIGN_BOTTOM)));
49986 }
49987 {
49988 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTER_VERTICAL)));
49989 }
49990 {
49991 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE_VERTICAL)));
49992 }
49993 {
49994 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int(static_cast<int >(wxALIGN_CENTER)));
49995 }
49996 {
49997 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int(static_cast<int >(wxALIGN_CENTRE)));
49998 }
49999 {
50000 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int(static_cast<int >(wxALIGN_MASK)));
50001 }
50002 {
50003 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int(static_cast<int >(wxSTRETCH_NOT)));
50004 }
50005 {
50006 PyDict_SetItemString(d,"SHRINK", SWIG_From_int(static_cast<int >(wxSHRINK)));
50007 }
50008 {
50009 PyDict_SetItemString(d,"GROW", SWIG_From_int(static_cast<int >(wxGROW)));
50010 }
50011 {
50012 PyDict_SetItemString(d,"EXPAND", SWIG_From_int(static_cast<int >(wxEXPAND)));
50013 }
50014 {
50015 PyDict_SetItemString(d,"SHAPED", SWIG_From_int(static_cast<int >(wxSHAPED)));
50016 }
50017 {
50018 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int(static_cast<int >(wxFIXED_MINSIZE)));
50019 }
50020 {
50021 PyDict_SetItemString(d,"TILE", SWIG_From_int(static_cast<int >(wxTILE)));
50022 }
50023 {
50024 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int(static_cast<int >(wxADJUST_MINSIZE)));
50025 }
50026 {
50027 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int(static_cast<int >(wxBORDER_DEFAULT)));
50028 }
50029 {
50030 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int(static_cast<int >(wxBORDER_NONE)));
50031 }
50032 {
50033 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int(static_cast<int >(wxBORDER_STATIC)));
50034 }
50035 {
50036 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int(static_cast<int >(wxBORDER_SIMPLE)));
50037 }
50038 {
50039 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int(static_cast<int >(wxBORDER_RAISED)));
50040 }
50041 {
50042 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int(static_cast<int >(wxBORDER_SUNKEN)));
50043 }
50044 {
50045 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int(static_cast<int >(wxBORDER_DOUBLE)));
50046 }
50047 {
50048 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int(static_cast<int >(wxBORDER_MASK)));
50049 }
50050 {
50051 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int(static_cast<int >(wxBG_STYLE_SYSTEM)));
50052 }
50053 {
50054 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int(static_cast<int >(wxBG_STYLE_COLOUR)));
50055 }
50056 {
50057 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int(static_cast<int >(wxBG_STYLE_CUSTOM)));
50058 }
50059 {
50060 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int(static_cast<int >(wxDEFAULT)));
50061 }
50062 {
50063 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int(static_cast<int >(wxDECORATIVE)));
50064 }
50065 {
50066 PyDict_SetItemString(d,"ROMAN", SWIG_From_int(static_cast<int >(wxROMAN)));
50067 }
50068 {
50069 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int(static_cast<int >(wxSCRIPT)));
50070 }
50071 {
50072 PyDict_SetItemString(d,"SWISS", SWIG_From_int(static_cast<int >(wxSWISS)));
50073 }
50074 {
50075 PyDict_SetItemString(d,"MODERN", SWIG_From_int(static_cast<int >(wxMODERN)));
50076 }
50077 {
50078 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int(static_cast<int >(wxTELETYPE)));
50079 }
50080 {
50081 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int(static_cast<int >(wxVARIABLE)));
50082 }
50083 {
50084 PyDict_SetItemString(d,"FIXED", SWIG_From_int(static_cast<int >(wxFIXED)));
50085 }
50086 {
50087 PyDict_SetItemString(d,"NORMAL", SWIG_From_int(static_cast<int >(wxNORMAL)));
50088 }
50089 {
50090 PyDict_SetItemString(d,"LIGHT", SWIG_From_int(static_cast<int >(wxLIGHT)));
50091 }
50092 {
50093 PyDict_SetItemString(d,"BOLD", SWIG_From_int(static_cast<int >(wxBOLD)));
50094 }
50095 {
50096 PyDict_SetItemString(d,"ITALIC", SWIG_From_int(static_cast<int >(wxITALIC)));
50097 }
50098 {
50099 PyDict_SetItemString(d,"SLANT", SWIG_From_int(static_cast<int >(wxSLANT)));
50100 }
50101 {
50102 PyDict_SetItemString(d,"SOLID", SWIG_From_int(static_cast<int >(wxSOLID)));
50103 }
50104 {
50105 PyDict_SetItemString(d,"DOT", SWIG_From_int(static_cast<int >(wxDOT)));
50106 }
50107 {
50108 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int(static_cast<int >(wxLONG_DASH)));
50109 }
50110 {
50111 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int(static_cast<int >(wxSHORT_DASH)));
50112 }
50113 {
50114 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int(static_cast<int >(wxDOT_DASH)));
50115 }
50116 {
50117 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int(static_cast<int >(wxUSER_DASH)));
50118 }
50119 {
50120 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int(static_cast<int >(wxTRANSPARENT)));
50121 }
50122 {
50123 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int(static_cast<int >(wxSTIPPLE)));
50124 }
50125 {
50126 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int(static_cast<int >(wxSTIPPLE_MASK)));
50127 }
50128 {
50129 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int(static_cast<int >(wxSTIPPLE_MASK_OPAQUE)));
50130 }
50131 {
50132 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int(static_cast<int >(wxBDIAGONAL_HATCH)));
50133 }
50134 {
50135 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int(static_cast<int >(wxCROSSDIAG_HATCH)));
50136 }
50137 {
50138 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int(static_cast<int >(wxFDIAGONAL_HATCH)));
50139 }
50140 {
50141 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int(static_cast<int >(wxCROSS_HATCH)));
50142 }
50143 {
50144 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int(static_cast<int >(wxHORIZONTAL_HATCH)));
50145 }
50146 {
50147 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int(static_cast<int >(wxVERTICAL_HATCH)));
50148 }
50149 {
50150 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int(static_cast<int >(wxJOIN_BEVEL)));
50151 }
50152 {
50153 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int(static_cast<int >(wxJOIN_MITER)));
50154 }
50155 {
50156 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int(static_cast<int >(wxJOIN_ROUND)));
50157 }
50158 {
50159 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int(static_cast<int >(wxCAP_ROUND)));
50160 }
50161 {
50162 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int(static_cast<int >(wxCAP_PROJECTING)));
50163 }
50164 {
50165 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int(static_cast<int >(wxCAP_BUTT)));
50166 }
50167 {
50168 PyDict_SetItemString(d,"CLEAR", SWIG_From_int(static_cast<int >(wxCLEAR)));
50169 }
50170 {
50171 PyDict_SetItemString(d,"XOR", SWIG_From_int(static_cast<int >(wxXOR)));
50172 }
50173 {
50174 PyDict_SetItemString(d,"INVERT", SWIG_From_int(static_cast<int >(wxINVERT)));
50175 }
50176 {
50177 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int(static_cast<int >(wxOR_REVERSE)));
50178 }
50179 {
50180 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int(static_cast<int >(wxAND_REVERSE)));
50181 }
50182 {
50183 PyDict_SetItemString(d,"COPY", SWIG_From_int(static_cast<int >(wxCOPY)));
50184 }
50185 {
50186 PyDict_SetItemString(d,"AND", SWIG_From_int(static_cast<int >(wxAND)));
50187 }
50188 {
50189 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int(static_cast<int >(wxAND_INVERT)));
50190 }
50191 {
50192 PyDict_SetItemString(d,"NO_OP", SWIG_From_int(static_cast<int >(wxNO_OP)));
50193 }
50194 {
50195 PyDict_SetItemString(d,"NOR", SWIG_From_int(static_cast<int >(wxNOR)));
50196 }
50197 {
50198 PyDict_SetItemString(d,"EQUIV", SWIG_From_int(static_cast<int >(wxEQUIV)));
50199 }
50200 {
50201 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int(static_cast<int >(wxSRC_INVERT)));
50202 }
50203 {
50204 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int(static_cast<int >(wxOR_INVERT)));
50205 }
50206 {
50207 PyDict_SetItemString(d,"NAND", SWIG_From_int(static_cast<int >(wxNAND)));
50208 }
50209 {
50210 PyDict_SetItemString(d,"OR", SWIG_From_int(static_cast<int >(wxOR)));
50211 }
50212 {
50213 PyDict_SetItemString(d,"SET", SWIG_From_int(static_cast<int >(wxSET)));
50214 }
50215 {
50216 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int(static_cast<int >(WXK_BACK)));
50217 }
50218 {
50219 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int(static_cast<int >(WXK_TAB)));
50220 }
50221 {
50222 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int(static_cast<int >(WXK_RETURN)));
50223 }
50224 {
50225 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int(static_cast<int >(WXK_ESCAPE)));
50226 }
50227 {
50228 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int(static_cast<int >(WXK_SPACE)));
50229 }
50230 {
50231 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int(static_cast<int >(WXK_DELETE)));
50232 }
50233 {
50234 PyDict_SetItemString(d,"WXK_START", SWIG_From_int(static_cast<int >(WXK_START)));
50235 }
50236 {
50237 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int(static_cast<int >(WXK_LBUTTON)));
50238 }
50239 {
50240 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int(static_cast<int >(WXK_RBUTTON)));
50241 }
50242 {
50243 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int(static_cast<int >(WXK_CANCEL)));
50244 }
50245 {
50246 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int(static_cast<int >(WXK_MBUTTON)));
50247 }
50248 {
50249 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int(static_cast<int >(WXK_CLEAR)));
50250 }
50251 {
50252 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int(static_cast<int >(WXK_SHIFT)));
50253 }
50254 {
50255 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int(static_cast<int >(WXK_ALT)));
50256 }
50257 {
50258 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int(static_cast<int >(WXK_CONTROL)));
50259 }
50260 {
50261 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int(static_cast<int >(WXK_MENU)));
50262 }
50263 {
50264 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int(static_cast<int >(WXK_PAUSE)));
50265 }
50266 {
50267 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int(static_cast<int >(WXK_CAPITAL)));
50268 }
50269 {
50270 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int(static_cast<int >(WXK_PRIOR)));
50271 }
50272 {
50273 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int(static_cast<int >(WXK_NEXT)));
50274 }
50275 {
50276 PyDict_SetItemString(d,"WXK_END", SWIG_From_int(static_cast<int >(WXK_END)));
50277 }
50278 {
50279 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int(static_cast<int >(WXK_HOME)));
50280 }
50281 {
50282 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int(static_cast<int >(WXK_LEFT)));
50283 }
50284 {
50285 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int(static_cast<int >(WXK_UP)));
50286 }
50287 {
50288 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int(static_cast<int >(WXK_RIGHT)));
50289 }
50290 {
50291 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int(static_cast<int >(WXK_DOWN)));
50292 }
50293 {
50294 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int(static_cast<int >(WXK_SELECT)));
50295 }
50296 {
50297 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int(static_cast<int >(WXK_PRINT)));
50298 }
50299 {
50300 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int(static_cast<int >(WXK_EXECUTE)));
50301 }
50302 {
50303 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int(static_cast<int >(WXK_SNAPSHOT)));
50304 }
50305 {
50306 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int(static_cast<int >(WXK_INSERT)));
50307 }
50308 {
50309 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int(static_cast<int >(WXK_HELP)));
50310 }
50311 {
50312 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int(static_cast<int >(WXK_NUMPAD0)));
50313 }
50314 {
50315 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int(static_cast<int >(WXK_NUMPAD1)));
50316 }
50317 {
50318 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int(static_cast<int >(WXK_NUMPAD2)));
50319 }
50320 {
50321 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int(static_cast<int >(WXK_NUMPAD3)));
50322 }
50323 {
50324 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int(static_cast<int >(WXK_NUMPAD4)));
50325 }
50326 {
50327 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int(static_cast<int >(WXK_NUMPAD5)));
50328 }
50329 {
50330 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int(static_cast<int >(WXK_NUMPAD6)));
50331 }
50332 {
50333 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int(static_cast<int >(WXK_NUMPAD7)));
50334 }
50335 {
50336 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int(static_cast<int >(WXK_NUMPAD8)));
50337 }
50338 {
50339 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int(static_cast<int >(WXK_NUMPAD9)));
50340 }
50341 {
50342 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int(static_cast<int >(WXK_MULTIPLY)));
50343 }
50344 {
50345 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int(static_cast<int >(WXK_ADD)));
50346 }
50347 {
50348 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int(static_cast<int >(WXK_SEPARATOR)));
50349 }
50350 {
50351 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int(static_cast<int >(WXK_SUBTRACT)));
50352 }
50353 {
50354 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int(static_cast<int >(WXK_DECIMAL)));
50355 }
50356 {
50357 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int(static_cast<int >(WXK_DIVIDE)));
50358 }
50359 {
50360 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int(static_cast<int >(WXK_F1)));
50361 }
50362 {
50363 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int(static_cast<int >(WXK_F2)));
50364 }
50365 {
50366 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int(static_cast<int >(WXK_F3)));
50367 }
50368 {
50369 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int(static_cast<int >(WXK_F4)));
50370 }
50371 {
50372 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int(static_cast<int >(WXK_F5)));
50373 }
50374 {
50375 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int(static_cast<int >(WXK_F6)));
50376 }
50377 {
50378 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int(static_cast<int >(WXK_F7)));
50379 }
50380 {
50381 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int(static_cast<int >(WXK_F8)));
50382 }
50383 {
50384 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int(static_cast<int >(WXK_F9)));
50385 }
50386 {
50387 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int(static_cast<int >(WXK_F10)));
50388 }
50389 {
50390 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int(static_cast<int >(WXK_F11)));
50391 }
50392 {
50393 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int(static_cast<int >(WXK_F12)));
50394 }
50395 {
50396 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int(static_cast<int >(WXK_F13)));
50397 }
50398 {
50399 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int(static_cast<int >(WXK_F14)));
50400 }
50401 {
50402 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int(static_cast<int >(WXK_F15)));
50403 }
50404 {
50405 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int(static_cast<int >(WXK_F16)));
50406 }
50407 {
50408 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int(static_cast<int >(WXK_F17)));
50409 }
50410 {
50411 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int(static_cast<int >(WXK_F18)));
50412 }
50413 {
50414 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int(static_cast<int >(WXK_F19)));
50415 }
50416 {
50417 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int(static_cast<int >(WXK_F20)));
50418 }
50419 {
50420 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int(static_cast<int >(WXK_F21)));
50421 }
50422 {
50423 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int(static_cast<int >(WXK_F22)));
50424 }
50425 {
50426 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int(static_cast<int >(WXK_F23)));
50427 }
50428 {
50429 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int(static_cast<int >(WXK_F24)));
50430 }
50431 {
50432 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int(static_cast<int >(WXK_NUMLOCK)));
50433 }
50434 {
50435 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int(static_cast<int >(WXK_SCROLL)));
50436 }
50437 {
50438 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int(static_cast<int >(WXK_PAGEUP)));
50439 }
50440 {
50441 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int(static_cast<int >(WXK_PAGEDOWN)));
50442 }
50443 {
50444 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SPACE)));
50445 }
50446 {
50447 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int(static_cast<int >(WXK_NUMPAD_TAB)));
50448 }
50449 {
50450 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int(static_cast<int >(WXK_NUMPAD_ENTER)));
50451 }
50452 {
50453 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F1)));
50454 }
50455 {
50456 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F2)));
50457 }
50458 {
50459 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F3)));
50460 }
50461 {
50462 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int(static_cast<int >(WXK_NUMPAD_F4)));
50463 }
50464 {
50465 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int(static_cast<int >(WXK_NUMPAD_HOME)));
50466 }
50467 {
50468 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_LEFT)));
50469 }
50470 {
50471 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int(static_cast<int >(WXK_NUMPAD_UP)));
50472 }
50473 {
50474 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_RIGHT)));
50475 }
50476 {
50477 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DOWN)));
50478 }
50479 {
50480 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PRIOR)));
50481 }
50482 {
50483 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PAGEUP)));
50484 }
50485 {
50486 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_NEXT)));
50487 }
50488 {
50489 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_PAGEDOWN)));
50490 }
50491 {
50492 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int(static_cast<int >(WXK_NUMPAD_END)));
50493 }
50494 {
50495 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int(static_cast<int >(WXK_NUMPAD_BEGIN)));
50496 }
50497 {
50498 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_INSERT)));
50499 }
50500 {
50501 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DELETE)));
50502 }
50503 {
50504 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int(static_cast<int >(WXK_NUMPAD_EQUAL)));
50505 }
50506 {
50507 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int(static_cast<int >(WXK_NUMPAD_MULTIPLY)));
50508 }
50509 {
50510 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int(static_cast<int >(WXK_NUMPAD_ADD)));
50511 }
50512 {
50513 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SEPARATOR)));
50514 }
50515 {
50516 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int(static_cast<int >(WXK_NUMPAD_SUBTRACT)));
50517 }
50518 {
50519 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DECIMAL)));
50520 }
50521 {
50522 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int(static_cast<int >(WXK_NUMPAD_DIVIDE)));
50523 }
50524 {
50525 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int(static_cast<int >(WXK_WINDOWS_LEFT)));
50526 }
50527 {
50528 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int(static_cast<int >(WXK_WINDOWS_RIGHT)));
50529 }
50530 {
50531 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int(static_cast<int >(WXK_WINDOWS_MENU)));
50532 }
50533 {
50534 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int(static_cast<int >(WXK_COMMAND)));
50535 }
50536 {
50537 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int(static_cast<int >(WXK_SPECIAL1)));
50538 }
50539 {
50540 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int(static_cast<int >(WXK_SPECIAL2)));
50541 }
50542 {
50543 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int(static_cast<int >(WXK_SPECIAL3)));
50544 }
50545 {
50546 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int(static_cast<int >(WXK_SPECIAL4)));
50547 }
50548 {
50549 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int(static_cast<int >(WXK_SPECIAL5)));
50550 }
50551 {
50552 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int(static_cast<int >(WXK_SPECIAL6)));
50553 }
50554 {
50555 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int(static_cast<int >(WXK_SPECIAL7)));
50556 }
50557 {
50558 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int(static_cast<int >(WXK_SPECIAL8)));
50559 }
50560 {
50561 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int(static_cast<int >(WXK_SPECIAL9)));
50562 }
50563 {
50564 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int(static_cast<int >(WXK_SPECIAL10)));
50565 }
50566 {
50567 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int(static_cast<int >(WXK_SPECIAL11)));
50568 }
50569 {
50570 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int(static_cast<int >(WXK_SPECIAL12)));
50571 }
50572 {
50573 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int(static_cast<int >(WXK_SPECIAL13)));
50574 }
50575 {
50576 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int(static_cast<int >(WXK_SPECIAL14)));
50577 }
50578 {
50579 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int(static_cast<int >(WXK_SPECIAL15)));
50580 }
50581 {
50582 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int(static_cast<int >(WXK_SPECIAL16)));
50583 }
50584 {
50585 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int(static_cast<int >(WXK_SPECIAL17)));
50586 }
50587 {
50588 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int(static_cast<int >(WXK_SPECIAL18)));
50589 }
50590 {
50591 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int(static_cast<int >(WXK_SPECIAL19)));
50592 }
50593 {
50594 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int(static_cast<int >(WXK_SPECIAL20)));
50595 }
50596 {
50597 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int(static_cast<int >(wxPAPER_NONE)));
50598 }
50599 {
50600 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int(static_cast<int >(wxPAPER_LETTER)));
50601 }
50602 {
50603 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int(static_cast<int >(wxPAPER_LEGAL)));
50604 }
50605 {
50606 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int(static_cast<int >(wxPAPER_A4)));
50607 }
50608 {
50609 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int(static_cast<int >(wxPAPER_CSHEET)));
50610 }
50611 {
50612 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int(static_cast<int >(wxPAPER_DSHEET)));
50613 }
50614 {
50615 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int(static_cast<int >(wxPAPER_ESHEET)));
50616 }
50617 {
50618 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int(static_cast<int >(wxPAPER_LETTERSMALL)));
50619 }
50620 {
50621 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int(static_cast<int >(wxPAPER_TABLOID)));
50622 }
50623 {
50624 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int(static_cast<int >(wxPAPER_LEDGER)));
50625 }
50626 {
50627 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int(static_cast<int >(wxPAPER_STATEMENT)));
50628 }
50629 {
50630 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int(static_cast<int >(wxPAPER_EXECUTIVE)));
50631 }
50632 {
50633 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int(static_cast<int >(wxPAPER_A3)));
50634 }
50635 {
50636 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int(static_cast<int >(wxPAPER_A4SMALL)));
50637 }
50638 {
50639 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int(static_cast<int >(wxPAPER_A5)));
50640 }
50641 {
50642 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int(static_cast<int >(wxPAPER_B4)));
50643 }
50644 {
50645 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int(static_cast<int >(wxPAPER_B5)));
50646 }
50647 {
50648 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int(static_cast<int >(wxPAPER_FOLIO)));
50649 }
50650 {
50651 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int(static_cast<int >(wxPAPER_QUARTO)));
50652 }
50653 {
50654 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int(static_cast<int >(wxPAPER_10X14)));
50655 }
50656 {
50657 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int(static_cast<int >(wxPAPER_11X17)));
50658 }
50659 {
50660 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int(static_cast<int >(wxPAPER_NOTE)));
50661 }
50662 {
50663 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int(static_cast<int >(wxPAPER_ENV_9)));
50664 }
50665 {
50666 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int(static_cast<int >(wxPAPER_ENV_10)));
50667 }
50668 {
50669 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int(static_cast<int >(wxPAPER_ENV_11)));
50670 }
50671 {
50672 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int(static_cast<int >(wxPAPER_ENV_12)));
50673 }
50674 {
50675 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int(static_cast<int >(wxPAPER_ENV_14)));
50676 }
50677 {
50678 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int(static_cast<int >(wxPAPER_ENV_DL)));
50679 }
50680 {
50681 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C5)));
50682 }
50683 {
50684 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C3)));
50685 }
50686 {
50687 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C4)));
50688 }
50689 {
50690 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C6)));
50691 }
50692 {
50693 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int(static_cast<int >(wxPAPER_ENV_C65)));
50694 }
50695 {
50696 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B4)));
50697 }
50698 {
50699 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B5)));
50700 }
50701 {
50702 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int(static_cast<int >(wxPAPER_ENV_B6)));
50703 }
50704 {
50705 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int(static_cast<int >(wxPAPER_ENV_ITALY)));
50706 }
50707 {
50708 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int(static_cast<int >(wxPAPER_ENV_MONARCH)));
50709 }
50710 {
50711 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int(static_cast<int >(wxPAPER_ENV_PERSONAL)));
50712 }
50713 {
50714 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_US)));
50715 }
50716 {
50717 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_STD_GERMAN)));
50718 }
50719 {
50720 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int(static_cast<int >(wxPAPER_FANFOLD_LGL_GERMAN)));
50721 }
50722 {
50723 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int(static_cast<int >(wxPAPER_ISO_B4)));
50724 }
50725 {
50726 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int(static_cast<int >(wxPAPER_JAPANESE_POSTCARD)));
50727 }
50728 {
50729 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int(static_cast<int >(wxPAPER_9X11)));
50730 }
50731 {
50732 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int(static_cast<int >(wxPAPER_10X11)));
50733 }
50734 {
50735 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int(static_cast<int >(wxPAPER_15X11)));
50736 }
50737 {
50738 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int(static_cast<int >(wxPAPER_ENV_INVITE)));
50739 }
50740 {
50741 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_EXTRA)));
50742 }
50743 {
50744 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_LEGAL_EXTRA)));
50745 }
50746 {
50747 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_TABLOID_EXTRA)));
50748 }
50749 {
50750 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A4_EXTRA)));
50751 }
50752 {
50753 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_TRANSVERSE)));
50754 }
50755 {
50756 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A4_TRANSVERSE)));
50757 }
50758 {
50759 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
50760 }
50761 {
50762 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_A_PLUS)));
50763 }
50764 {
50765 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_B_PLUS)));
50766 }
50767 {
50768 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_PLUS)));
50769 }
50770 {
50771 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int(static_cast<int >(wxPAPER_A4_PLUS)));
50772 }
50773 {
50774 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A5_TRANSVERSE)));
50775 }
50776 {
50777 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_B5_TRANSVERSE)));
50778 }
50779 {
50780 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A3_EXTRA)));
50781 }
50782 {
50783 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_A5_EXTRA)));
50784 }
50785 {
50786 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int(static_cast<int >(wxPAPER_B5_EXTRA)));
50787 }
50788 {
50789 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int(static_cast<int >(wxPAPER_A2)));
50790 }
50791 {
50792 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A3_TRANSVERSE)));
50793 }
50794 {
50795 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int(static_cast<int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
50796 }
50797 {
50798 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD", SWIG_From_int(static_cast<int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
50799 }
50800 {
50801 PyDict_SetItemString(d,"PAPER_A6", SWIG_From_int(static_cast<int >(wxPAPER_A6)));
50802 }
50803 {
50804 PyDict_SetItemString(d,"PAPER_JENV_KAKU2", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU2)));
50805 }
50806 {
50807 PyDict_SetItemString(d,"PAPER_JENV_KAKU3", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU3)));
50808 }
50809 {
50810 PyDict_SetItemString(d,"PAPER_JENV_CHOU3", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU3)));
50811 }
50812 {
50813 PyDict_SetItemString(d,"PAPER_JENV_CHOU4", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU4)));
50814 }
50815 {
50816 PyDict_SetItemString(d,"PAPER_LETTER_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_LETTER_ROTATED)));
50817 }
50818 {
50819 PyDict_SetItemString(d,"PAPER_A3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A3_ROTATED)));
50820 }
50821 {
50822 PyDict_SetItemString(d,"PAPER_A4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A4_ROTATED)));
50823 }
50824 {
50825 PyDict_SetItemString(d,"PAPER_A5_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A5_ROTATED)));
50826 }
50827 {
50828 PyDict_SetItemString(d,"PAPER_B4_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B4_JIS_ROTATED)));
50829 }
50830 {
50831 PyDict_SetItemString(d,"PAPER_B5_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B5_JIS_ROTATED)));
50832 }
50833 {
50834 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
50835 }
50836 {
50837 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
50838 }
50839 {
50840 PyDict_SetItemString(d,"PAPER_A6_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_A6_ROTATED)));
50841 }
50842 {
50843 PyDict_SetItemString(d,"PAPER_JENV_KAKU2_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU2_ROTATED)));
50844 }
50845 {
50846 PyDict_SetItemString(d,"PAPER_JENV_KAKU3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_KAKU3_ROTATED)));
50847 }
50848 {
50849 PyDict_SetItemString(d,"PAPER_JENV_CHOU3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU3_ROTATED)));
50850 }
50851 {
50852 PyDict_SetItemString(d,"PAPER_JENV_CHOU4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_CHOU4_ROTATED)));
50853 }
50854 {
50855 PyDict_SetItemString(d,"PAPER_B6_JIS", SWIG_From_int(static_cast<int >(wxPAPER_B6_JIS)));
50856 }
50857 {
50858 PyDict_SetItemString(d,"PAPER_B6_JIS_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_B6_JIS_ROTATED)));
50859 }
50860 {
50861 PyDict_SetItemString(d,"PAPER_12X11", SWIG_From_int(static_cast<int >(wxPAPER_12X11)));
50862 }
50863 {
50864 PyDict_SetItemString(d,"PAPER_JENV_YOU4", SWIG_From_int(static_cast<int >(wxPAPER_JENV_YOU4)));
50865 }
50866 {
50867 PyDict_SetItemString(d,"PAPER_JENV_YOU4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_JENV_YOU4_ROTATED)));
50868 }
50869 {
50870 PyDict_SetItemString(d,"PAPER_P16K", SWIG_From_int(static_cast<int >(wxPAPER_P16K)));
50871 }
50872 {
50873 PyDict_SetItemString(d,"PAPER_P32K", SWIG_From_int(static_cast<int >(wxPAPER_P32K)));
50874 }
50875 {
50876 PyDict_SetItemString(d,"PAPER_P32KBIG", SWIG_From_int(static_cast<int >(wxPAPER_P32KBIG)));
50877 }
50878 {
50879 PyDict_SetItemString(d,"PAPER_PENV_1", SWIG_From_int(static_cast<int >(wxPAPER_PENV_1)));
50880 }
50881 {
50882 PyDict_SetItemString(d,"PAPER_PENV_2", SWIG_From_int(static_cast<int >(wxPAPER_PENV_2)));
50883 }
50884 {
50885 PyDict_SetItemString(d,"PAPER_PENV_3", SWIG_From_int(static_cast<int >(wxPAPER_PENV_3)));
50886 }
50887 {
50888 PyDict_SetItemString(d,"PAPER_PENV_4", SWIG_From_int(static_cast<int >(wxPAPER_PENV_4)));
50889 }
50890 {
50891 PyDict_SetItemString(d,"PAPER_PENV_5", SWIG_From_int(static_cast<int >(wxPAPER_PENV_5)));
50892 }
50893 {
50894 PyDict_SetItemString(d,"PAPER_PENV_6", SWIG_From_int(static_cast<int >(wxPAPER_PENV_6)));
50895 }
50896 {
50897 PyDict_SetItemString(d,"PAPER_PENV_7", SWIG_From_int(static_cast<int >(wxPAPER_PENV_7)));
50898 }
50899 {
50900 PyDict_SetItemString(d,"PAPER_PENV_8", SWIG_From_int(static_cast<int >(wxPAPER_PENV_8)));
50901 }
50902 {
50903 PyDict_SetItemString(d,"PAPER_PENV_9", SWIG_From_int(static_cast<int >(wxPAPER_PENV_9)));
50904 }
50905 {
50906 PyDict_SetItemString(d,"PAPER_PENV_10", SWIG_From_int(static_cast<int >(wxPAPER_PENV_10)));
50907 }
50908 {
50909 PyDict_SetItemString(d,"PAPER_P16K_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P16K_ROTATED)));
50910 }
50911 {
50912 PyDict_SetItemString(d,"PAPER_P32K_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P32K_ROTATED)));
50913 }
50914 {
50915 PyDict_SetItemString(d,"PAPER_P32KBIG_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_P32KBIG_ROTATED)));
50916 }
50917 {
50918 PyDict_SetItemString(d,"PAPER_PENV_1_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_1_ROTATED)));
50919 }
50920 {
50921 PyDict_SetItemString(d,"PAPER_PENV_2_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_2_ROTATED)));
50922 }
50923 {
50924 PyDict_SetItemString(d,"PAPER_PENV_3_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_3_ROTATED)));
50925 }
50926 {
50927 PyDict_SetItemString(d,"PAPER_PENV_4_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_4_ROTATED)));
50928 }
50929 {
50930 PyDict_SetItemString(d,"PAPER_PENV_5_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_5_ROTATED)));
50931 }
50932 {
50933 PyDict_SetItemString(d,"PAPER_PENV_6_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_6_ROTATED)));
50934 }
50935 {
50936 PyDict_SetItemString(d,"PAPER_PENV_7_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_7_ROTATED)));
50937 }
50938 {
50939 PyDict_SetItemString(d,"PAPER_PENV_8_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_8_ROTATED)));
50940 }
50941 {
50942 PyDict_SetItemString(d,"PAPER_PENV_9_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_9_ROTATED)));
50943 }
50944 {
50945 PyDict_SetItemString(d,"PAPER_PENV_10_ROTATED", SWIG_From_int(static_cast<int >(wxPAPER_PENV_10_ROTATED)));
50946 }
50947 {
50948 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int(static_cast<int >(wxDUPLEX_SIMPLEX)));
50949 }
50950 {
50951 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int(static_cast<int >(wxDUPLEX_HORIZONTAL)));
50952 }
50953 {
50954 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int(static_cast<int >(wxDUPLEX_VERTICAL)));
50955 }
50956 {
50957 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int(static_cast<int >(wxITEM_SEPARATOR)));
50958 }
50959 {
50960 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int(static_cast<int >(wxITEM_NORMAL)));
50961 }
50962 {
50963 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int(static_cast<int >(wxITEM_CHECK)));
50964 }
50965 {
50966 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int(static_cast<int >(wxITEM_RADIO)));
50967 }
50968 {
50969 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int(static_cast<int >(wxITEM_MAX)));
50970 }
50971 {
50972 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int(static_cast<int >(wxHT_NOWHERE)));
50973 }
50974 {
50975 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_FIRST)));
50976 }
50977 {
50978 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
50979 }
50980 {
50981 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
50982 }
50983 {
50984 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
50985 }
50986 {
50987 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
50988 }
50989 {
50990 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_THUMB)));
50991 }
50992 {
50993 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_BAR_1)));
50994 }
50995 {
50996 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_BAR_2)));
50997 }
50998 {
50999 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int(static_cast<int >(wxHT_SCROLLBAR_LAST)));
51000 }
51001 {
51002 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int(static_cast<int >(wxHT_WINDOW_OUTSIDE)));
51003 }
51004 {
51005 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int(static_cast<int >(wxHT_WINDOW_INSIDE)));
51006 }
51007 {
51008 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int(static_cast<int >(wxHT_WINDOW_VERT_SCROLLBAR)));
51009 }
51010 {
51011 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int(static_cast<int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
51012 }
51013 {
51014 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int(static_cast<int >(wxHT_WINDOW_CORNER)));
51015 }
51016 {
51017 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int(static_cast<int >(wxHT_MAX)));
51018 }
51019 {
51020 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int(static_cast<int >(wxMOD_NONE)));
51021 }
51022 {
51023 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int(static_cast<int >(wxMOD_ALT)));
51024 }
51025 {
51026 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int(static_cast<int >(wxMOD_CONTROL)));
51027 }
51028 {
51029 PyDict_SetItemString(d,"MOD_ALTGR", SWIG_From_int(static_cast<int >(wxMOD_ALTGR)));
51030 }
51031 {
51032 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int(static_cast<int >(wxMOD_SHIFT)));
51033 }
51034 {
51035 PyDict_SetItemString(d,"MOD_META", SWIG_From_int(static_cast<int >(wxMOD_META)));
51036 }
51037 {
51038 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int(static_cast<int >(wxMOD_WIN)));
51039 }
51040 {
51041 PyDict_SetItemString(d,"MOD_CMD", SWIG_From_int(static_cast<int >(wxMOD_CMD)));
51042 }
51043 {
51044 PyDict_SetItemString(d,"MOD_ALL", SWIG_From_int(static_cast<int >(wxMOD_ALL)));
51045 }
51046 {
51047 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_NONE)));
51048 }
51049 {
51050 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_RECURSE)));
51051 }
51052 {
51053 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int(static_cast<int >(wxUPDATE_UI_FROMIDLE)));
51054 }
51055 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
51056 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
51057 {
51058 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_INVALID)));
51059 }
51060 {
51061 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_BMP)));
51062 }
51063 {
51064 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ICO)));
51065 }
51066 {
51067 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_CUR)));
51068 }
51069 {
51070 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XBM)));
51071 }
51072 {
51073 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XBM_DATA)));
51074 }
51075 {
51076 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XPM)));
51077 }
51078 {
51079 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_XPM_DATA)));
51080 }
51081 {
51082 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_TIF)));
51083 }
51084 {
51085 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_GIF)));
51086 }
51087 {
51088 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PNG)));
51089 }
51090 {
51091 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_JPEG)));
51092 }
51093 {
51094 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PNM)));
51095 }
51096 {
51097 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PCX)));
51098 }
51099 {
51100 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_PICT)));
51101 }
51102 {
51103 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ICON)));
51104 }
51105 {
51106 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ANI)));
51107 }
51108 {
51109 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_IFF)));
51110 }
51111 {
51112 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_MACCURSOR)));
51113 }
51114 {
51115 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int(static_cast<int >(wxBITMAP_TYPE_ANY)));
51116 }
51117 {
51118 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int(static_cast<int >(wxCURSOR_NONE)));
51119 }
51120 {
51121 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_ARROW)));
51122 }
51123 {
51124 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_RIGHT_ARROW)));
51125 }
51126 {
51127 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int(static_cast<int >(wxCURSOR_BULLSEYE)));
51128 }
51129 {
51130 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int(static_cast<int >(wxCURSOR_CHAR)));
51131 }
51132 {
51133 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int(static_cast<int >(wxCURSOR_CROSS)));
51134 }
51135 {
51136 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int(static_cast<int >(wxCURSOR_HAND)));
51137 }
51138 {
51139 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int(static_cast<int >(wxCURSOR_IBEAM)));
51140 }
51141 {
51142 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_LEFT_BUTTON)));
51143 }
51144 {
51145 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int(static_cast<int >(wxCURSOR_MAGNIFIER)));
51146 }
51147 {
51148 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_MIDDLE_BUTTON)));
51149 }
51150 {
51151 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int(static_cast<int >(wxCURSOR_NO_ENTRY)));
51152 }
51153 {
51154 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int(static_cast<int >(wxCURSOR_PAINT_BRUSH)));
51155 }
51156 {
51157 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int(static_cast<int >(wxCURSOR_PENCIL)));
51158 }
51159 {
51160 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int(static_cast<int >(wxCURSOR_POINT_LEFT)));
51161 }
51162 {
51163 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int(static_cast<int >(wxCURSOR_POINT_RIGHT)));
51164 }
51165 {
51166 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_QUESTION_ARROW)));
51167 }
51168 {
51169 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int(static_cast<int >(wxCURSOR_RIGHT_BUTTON)));
51170 }
51171 {
51172 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENESW)));
51173 }
51174 {
51175 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENS)));
51176 }
51177 {
51178 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int(static_cast<int >(wxCURSOR_SIZENWSE)));
51179 }
51180 {
51181 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int(static_cast<int >(wxCURSOR_SIZEWE)));
51182 }
51183 {
51184 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int(static_cast<int >(wxCURSOR_SIZING)));
51185 }
51186 {
51187 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int(static_cast<int >(wxCURSOR_SPRAYCAN)));
51188 }
51189 {
51190 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int(static_cast<int >(wxCURSOR_WAIT)));
51191 }
51192 {
51193 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int(static_cast<int >(wxCURSOR_WATCH)));
51194 }
51195 {
51196 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int(static_cast<int >(wxCURSOR_BLANK)));
51197 }
51198 {
51199 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int(static_cast<int >(wxCURSOR_DEFAULT)));
51200 }
51201 {
51202 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int(static_cast<int >(wxCURSOR_COPY_ARROW)));
51203 }
51204 {
51205 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int(static_cast<int >(wxCURSOR_ARROWWAIT)));
51206 }
51207 {
51208 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int(static_cast<int >(wxCURSOR_MAX)));
51209 }
51210 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
51211 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
51212 {
51213 PyDict_SetItemString(d,"FromStart", SWIG_From_int(static_cast<int >(wxFromStart)));
51214 }
51215 {
51216 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int(static_cast<int >(wxFromCurrent)));
51217 }
51218 {
51219 PyDict_SetItemString(d,"FromEnd", SWIG_From_int(static_cast<int >(wxFromEnd)));
51220 }
51221
51222 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
51223
51224
51225 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
51226
51227 {
51228 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_TRANSPARENT)));
51229 }
51230 {
51231 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_THRESHOLD)));
51232 }
51233 {
51234 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int(static_cast<int >(wxIMAGE_ALPHA_OPAQUE)));
51235 }
51236 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
51237 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
51238 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
51239 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
51240 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
51241 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
51242 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
51243 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
51244 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
51245 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
51246 {
51247 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int(static_cast<int >(wxIMAGE_RESOLUTION_INCHES)));
51248 }
51249 {
51250 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int(static_cast<int >(wxIMAGE_RESOLUTION_CM)));
51251 }
51252 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
51253 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
51254 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
51255 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
51256 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
51257 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
51258 {
51259 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int(static_cast<int >(wxPNG_TYPE_COLOUR)));
51260 }
51261 {
51262 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int(static_cast<int >(wxPNG_TYPE_GREY)));
51263 }
51264 {
51265 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int(static_cast<int >(wxPNG_TYPE_GREY_RED)));
51266 }
51267 {
51268 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int(static_cast<int >(wxBMP_24BPP)));
51269 }
51270 {
51271 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int(static_cast<int >(wxBMP_8BPP)));
51272 }
51273 {
51274 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int(static_cast<int >(wxBMP_8BPP_GREY)));
51275 }
51276 {
51277 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int(static_cast<int >(wxBMP_8BPP_GRAY)));
51278 }
51279 {
51280 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int(static_cast<int >(wxBMP_8BPP_RED)));
51281 }
51282 {
51283 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int(static_cast<int >(wxBMP_8BPP_PALETTE)));
51284 }
51285 {
51286 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int(static_cast<int >(wxBMP_4BPP)));
51287 }
51288 {
51289 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int(static_cast<int >(wxBMP_1BPP)));
51290 }
51291 {
51292 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int(static_cast<int >(wxBMP_1BPP_BW)));
51293 }
51294 {
51295 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int(static_cast<int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
51296 }
51297 {
51298 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int(static_cast<int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
51299 }
51300 {
51301 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int(static_cast<int >(wxEVENT_PROPAGATE_NONE)));
51302 }
51303 {
51304 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int(static_cast<int >(wxEVENT_PROPAGATE_MAX)));
51305 }
51306 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
51307 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
51308 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
51309 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
51310 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
51311 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
51312 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
51313 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
51314 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
51315 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
51316 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
51317 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
51318 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
51319 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
51320 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
51321 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
51322 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
51323 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
51324 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
51325 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
51326 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
51327 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
51328 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
51329 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
51330 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
51331 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
51332 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
51333 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
51334 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
51335 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
51336 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
51337 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
51338 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
51339 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
51340 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
51341 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
51342 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
51343 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
51344 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
51345 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
51346 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
51347 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
51348 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
51349 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
51350 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
51351 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
51352 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
51353 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
51354 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
51355 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
51356 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
51357 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
51358 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
51359 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
51360 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
51361 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
51362 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
51363 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
51364 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
51365 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
51366 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
51367 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
51368 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
51369 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
51370 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
51371 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
51372 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
51373 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
51374 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
51375 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
51376 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
51377 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
51378 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
51379 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
51380 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
51381 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
51382 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
51383 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
51384 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
51385 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
51386 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
51387 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
51388 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
51389 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
51390 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
51391 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
51392 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
51393 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
51394 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
51395 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
51396 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
51397 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
51398 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
51399 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
51400 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
51401 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
51402 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
51403 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
51404 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
51405 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
51406 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
51407 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
51408 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
51409 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
51410 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
51411 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
51412 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
51413 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
51414 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
51415 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
51416 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
51417 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
51418 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
51419 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
51420 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
51421 {
51422 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_ANY)));
51423 }
51424 {
51425 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_NONE)));
51426 }
51427 {
51428 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_LEFT)));
51429 }
51430 {
51431 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_MIDDLE)));
51432 }
51433 {
51434 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int(static_cast<int >(wxMOUSE_BTN_RIGHT)));
51435 }
51436 {
51437 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int(static_cast<int >(wxUPDATE_UI_PROCESS_ALL)));
51438 }
51439 {
51440 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int(static_cast<int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
51441 }
51442 {
51443 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::IsBackward)));
51444 }
51445 {
51446 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::IsForward)));
51447 }
51448 {
51449 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::WinChange)));
51450 }
51451 {
51452 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int(static_cast<int >(wxNavigationKeyEvent::FromTab)));
51453 }
51454 {
51455 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int(static_cast<int >(wxIDLE_PROCESS_ALL)));
51456 }
51457 {
51458 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int(static_cast<int >(wxIDLE_PROCESS_SPECIFIED)));
51459 }
51460 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
51461 {
51462 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_SUPPRESS)));
51463 }
51464 {
51465 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_EXCEPTION)));
51466 }
51467 {
51468 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_DIALOG)));
51469 }
51470 {
51471 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int(static_cast<int >(wxPYAPP_ASSERT_LOG)));
51472 }
51473 {
51474 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int(static_cast<int >(wxPRINT_WINDOWS)));
51475 }
51476 {
51477 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int(static_cast<int >(wxPRINT_POSTSCRIPT)));
51478 }
51479 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
51480 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
51481 {
51482 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_NORMAL)));
51483 }
51484 {
51485 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_SMALL)));
51486 }
51487 {
51488 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_MINI)));
51489 }
51490 {
51491 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_LARGE)));
51492 }
51493 {
51494 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int(static_cast<int >(wxWINDOW_VARIANT_MAX)));
51495 }
51496 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
51497 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
51498 {
51499 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_NONE)));
51500 }
51501 {
51502 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_SPECIFIED)));
51503 }
51504 {
51505 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int(static_cast<int >(wxFLEX_GROWMODE_ALL)));
51506 }
51507 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
51508 {
51509 PyDict_SetItemString(d,"Left", SWIG_From_int(static_cast<int >(wxLeft)));
51510 }
51511 {
51512 PyDict_SetItemString(d,"Top", SWIG_From_int(static_cast<int >(wxTop)));
51513 }
51514 {
51515 PyDict_SetItemString(d,"Right", SWIG_From_int(static_cast<int >(wxRight)));
51516 }
51517 {
51518 PyDict_SetItemString(d,"Bottom", SWIG_From_int(static_cast<int >(wxBottom)));
51519 }
51520 {
51521 PyDict_SetItemString(d,"Width", SWIG_From_int(static_cast<int >(wxWidth)));
51522 }
51523 {
51524 PyDict_SetItemString(d,"Height", SWIG_From_int(static_cast<int >(wxHeight)));
51525 }
51526 {
51527 PyDict_SetItemString(d,"Centre", SWIG_From_int(static_cast<int >(wxCentre)));
51528 }
51529 {
51530 PyDict_SetItemString(d,"Center", SWIG_From_int(static_cast<int >(wxCenter)));
51531 }
51532 {
51533 PyDict_SetItemString(d,"CentreX", SWIG_From_int(static_cast<int >(wxCentreX)));
51534 }
51535 {
51536 PyDict_SetItemString(d,"CentreY", SWIG_From_int(static_cast<int >(wxCentreY)));
51537 }
51538 {
51539 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int(static_cast<int >(wxUnconstrained)));
51540 }
51541 {
51542 PyDict_SetItemString(d,"AsIs", SWIG_From_int(static_cast<int >(wxAsIs)));
51543 }
51544 {
51545 PyDict_SetItemString(d,"PercentOf", SWIG_From_int(static_cast<int >(wxPercentOf)));
51546 }
51547 {
51548 PyDict_SetItemString(d,"Above", SWIG_From_int(static_cast<int >(wxAbove)));
51549 }
51550 {
51551 PyDict_SetItemString(d,"Below", SWIG_From_int(static_cast<int >(wxBelow)));
51552 }
51553 {
51554 PyDict_SetItemString(d,"LeftOf", SWIG_From_int(static_cast<int >(wxLeftOf)));
51555 }
51556 {
51557 PyDict_SetItemString(d,"RightOf", SWIG_From_int(static_cast<int >(wxRightOf)));
51558 }
51559 {
51560 PyDict_SetItemString(d,"SameAs", SWIG_From_int(static_cast<int >(wxSameAs)));
51561 }
51562 {
51563 PyDict_SetItemString(d,"Absolute", SWIG_From_int(static_cast<int >(wxAbsolute)));
51564 }
51565
51566 // Initialize threading, some globals and such
51567 __wxPyPreStart(d);
51568
51569
51570 // Although these are defined in __version__ they need to be here too so
51571 // that an assert can be done to ensure that the wxPython and the wxWindows
51572 // versions match.
51573 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
51574 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
51575 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
51576
51577 }
51578
wxWidgets (Impactor)